home *** CD-ROM | disk | FTP | other *** search
/ Atari Mega Archive 2 / Atari Mega Archive CD - Volume 2.iso / linux / src / lnx09p4.dgz / linux-0.9pl4.diffs
Text File  |  1994-11-24  |  430KB  |  14,397 lines
  1. diff -ubr -x RCS -x *.[ao] -x .depend -x .version -x .config -x System.map -x vmlinux -x bootstrap -x *~ -x config.old -x *.orig -x *.rej -x *# -x version.h -x autoconf.h --new-file linux-0.9pl3/MakeVars linux-0.9pl4/MakeVars
  2. --- linux-0.9pl3/MakeVars    Sun Aug 14 10:30:54 1994
  3. +++ linux-0.9pl4/MakeVars    Mon Nov 21 18:08:53 1994
  4. @@ -20,7 +20,7 @@
  5.  ASINCS         = $(INCFLAGS) -O2
  6.  HOSTINCFLAGS     = -Dlinux
  7.  HOSTFLAGS     = -O2 -Wall $(HOSTINCFLAGS)
  8. -LDFLAGS      =
  9. +LDFLAGS      = -qmagic -Ttext 0xC0000FE0
  10.  AR         = ar
  11.  RANLIB         = ranlib
  12.  
  13. diff -ubr -x RCS -x *.[ao] -x .depend -x .version -x .config -x System.map -x vmlinux -x bootstrap -x *~ -x config.old -x *.orig -x *.rej -x *# -x version.h -x autoconf.h --new-file linux-0.9pl3/Makefile linux-0.9pl4/Makefile
  14. --- linux-0.9pl3/Makefile    Tue Sep 27 22:18:26 1994
  15. +++ linux-0.9pl4/Makefile    Mon Nov 21 18:08:53 1994
  16. @@ -1,6 +1,6 @@
  17. -# Makefile for Amiga Linux main source directory
  18. +# Makefile for Linux/68k main source directory
  19.  #
  20. -# Copyright 1993 by Hamish Macdonald
  21. +# Copyright 1993,1994 by Hamish Macdonald
  22.  #
  23.  # This file is subject to the terms and conditions of the GNU General Public
  24.  # License.  See the file "README.legal" in the main directory of this archive
  25. @@ -8,7 +8,7 @@
  26.  
  27.  VERSION = 0
  28.  PATCHLEVEL = 9
  29. -SUBLEVEL = 3
  30. +SUBLEVEL = 4
  31.  
  32.  all:    Version vmlinux
  33.  
  34. @@ -76,13 +76,13 @@
  35.  endif
  36.  
  37.  ifdef CONFIG_AMIGA
  38. -AMIGA_BOOTOBJS := tools/amiga/bootstrap.o tools/amiga/get_nlist.o
  39. +AMIGA_BOOTOBJS := tools/amiga/bootstrap.o
  40.  ARCHIVES := $(ARCHIVES) amiga/amiga.o
  41.  SUBDIRS := $(SUBDIRS) amiga
  42.  endif
  43.  
  44.  ifdef CONFIG_ATARI
  45. -ATARI_BOOTOBJS := tools/atari/bootstrap.o tools/atari/get_nlist.o
  46. +ATARI_BOOTOBJS := tools/atari/bootstrap.o
  47.  ARCHIVES := $(ARCHIVES) atari/atari.o
  48.  SUBDIRS := $(SUBDIRS) atari
  49.  endif
  50. @@ -145,7 +145,7 @@
  51.      $(CC) $(CFLAGS) -c -o $*.o $<
  52.  
  53.  vmlinux: m68k/head.o init/main.o init/config.o tools/version.o linuxsubdirs
  54. -    $(LD) $(LDFLAGS) -T 0xC0000000 -M m68k/head.o init/main.o init/config.o \
  55. +    $(LD) $(LDFLAGS) -M m68k/head.o init/main.o init/config.o \
  56.          tools/version.o \
  57.          $(ARCHIVES) \
  58.          $(FILESYSTEMS) \
  59. diff -ubr -x RCS -x *.[ao] -x .depend -x .version -x .config -x System.map -x vmlinux -x bootstrap -x *~ -x config.old -x *.orig -x *.rej -x *# -x version.h -x autoconf.h --new-file linux-0.9pl3/amiga/amicon.c linux-0.9pl4/amiga/amicon.c
  60. --- linux-0.9pl3/amiga/amicon.c    Sun Aug 14 10:29:40 1994
  61. +++ linux-0.9pl4/amiga/amicon.c    Thu Nov 10 17:56:32 1994
  62. @@ -1079,8 +1079,6 @@
  63.      char *this_opt;
  64.      int i;
  65.      
  66. -    printk ("video_setup: options are %s\n", options);
  67. -    
  68.      if (!options || !*options) {
  69.          return;
  70.      }
  71. @@ -1102,13 +1100,17 @@
  72.      }
  73.      }
  74.  
  75. -static long amicon_init(struct condata *conp, long kmem_start)
  76. +static long amicon_init(struct condata *conp, long kmem_start, char**display_desc)
  77.  {
  78.     int unit = conp - vc_cons;
  79.     register struct display *p = &disp[unit];
  80.     int mode = amicon_mode;
  81.     int inverse_video = amicon_inverse;
  82.     ulong  model;
  83. +   static int master_init = 0;
  84. +
  85. +   if(master_init==0)
  86. +   {
  87.  
  88.     model = boot_info.bi_un.bi_ami.model;
  89.  
  90. @@ -1128,14 +1130,29 @@
  91.         }
  92.         }
  93.  
  94. +      *display_desc = modes[mode].modename;
  95.     init_vblank();
  96. +   
  97.     display_init(p, &modes[mode], inverse_video);
  98. +   }
  99. +   else
  100. +   {
  101. +      /* Copy all from the first console, maybe allow different
  102. +         display modes later. */
  103. +      disp[unit] = disp[0];
  104. +   }
  105.  
  106. -   conp->vc_cols = p->scr_width  / p->fontwidth;
  107. -   conp->vc_rows = p->scr_height / p->fontheight;
  108. +   conp->vc_cols = disp[unit].scr_width / disp[unit].fontwidth;
  109. +   conp->vc_rows = disp[unit].scr_height / disp[unit].fontheight;
  110. +   conp->vc_can_do_color = 0;
  111. +   conp->vc_flags |= CON_INITED;
  112.  
  113. +   if(master_init==0)
  114. +   {
  115.     if(!mach_add_isr(IRQ_AMIGA_VERTB, (isrfunc)amicon_interrupt, 0, NULL))
  116.             panic("Couldn't add vblank interrupt");
  117. +      master_init=1;
  118. +   }
  119.  
  120.  #ifdef DEBUG
  121.     printk("amicon_init: fired up mode %s\n", modes[mode].modename);
  122. @@ -1147,6 +1164,17 @@
  123.  
  124.  static int amicon_deinit (struct condata *conp)
  125.  {
  126. +  struct display *p = &disp[conp - vc_cons];
  127. +  static int amicon_switch (struct condata *conp);
  128. +
  129. +  /* You can't deinit a non inited screen nor the console 0. */
  130. +  if (!(conp->vc_flags & CON_INITED) || p == disp)
  131. +    return -1;
  132. +
  133. +  amicon_switch (&vc_cons[0]);    /* Always switch to the console 0 */
  134. +  memset (p, 0, sizeof (struct display));
  135. +  conp->vc_flags &= ~CON_INITED;
  136. +
  137.      return 0;
  138.  }
  139.  
  140. @@ -1389,9 +1417,11 @@
  141.            int sy, int sx, int dy, int dx,
  142.            int height, int width)
  143.  {
  144. -    int unit = conp - vc_cons;
  145. +    int unit=0;
  146. +/*    int unit = conp - vc_cons;*/
  147.      struct display *p = &disp[unit];
  148.  
  149. +
  150.      if (p->fontwidth == 8) {
  151.          /* Split blits that cross physical y_wrap case.
  152.           * Pathological case involves 4 blits, better to use recursive
  153. @@ -1463,7 +1493,8 @@
  154.  static int amicon_clear (struct condata *conp,
  155.                           int sy, int sx, int height, int width)
  156.  {
  157. -    int unit = conp - vc_cons;
  158. +    int unit = 0;
  159. +    /*int unit = conp - vc_cons;*/
  160.      register struct display *p = &disp[unit];
  161.  
  162.      if (p->fontwidth == 8) {
  163. @@ -1489,7 +1520,7 @@
  164.  }
  165.  
  166.  static void amicon_putc_physical_8 (struct display *p,
  167. -                                    int c, int y, int x, int mode)
  168. +                                    int c, int y, int x, int attr)
  169.  {
  170.      register u_char   *dest;
  171.      register u_char   *cdat;
  172. @@ -1519,14 +1550,10 @@
  173.       */
  174.  
  175.      for (rows = p->fontheight ; rows-- ; dest += bytes)
  176. -    switch (mode) {
  177. -      case DM_COPY:
  178. -        *dest = *cdat++;
  179. -        break;
  180. -      case DM_INVERSE:
  181. +      if (attr & 8)
  182.          *dest = ~*cdat++;
  183. -        break;
  184. -    }
  185. +      else
  186. +    *dest = *cdat++;
  187.  
  188.      for (i = 1 ; i < p->scr_depth ; i++) {
  189.          dest = p->bitplane[i] + offset;
  190. @@ -1535,14 +1562,14 @@
  191.      }
  192.  }
  193.  
  194. -static int amicon_putc (struct condata *conp,
  195. -                        int c, int y, int x, int mode)
  196. +static int amicon_putc (struct condata *conp, int c, int y, int x)
  197.  {
  198. -    int unit = conp - vc_cons;
  199. +    int unit = 0;
  200. +    /*int unit = conp - vc_cons;*/
  201.      register struct display *p = &disp[unit];
  202.  
  203.      if (p->fontwidth == 8) {
  204. -        amicon_putc_physical_8(p, c, real_y_8(p, y) , x, mode);
  205. +        amicon_putc_physical_8(p, c, real_y_8(p, y) , x, conp->vc_attr);
  206.      } else {
  207.          /* Currently no support for (fontwidth != 8) */
  208.      }
  209. @@ -1551,7 +1578,7 @@
  210.  }
  211.  
  212.  static void amicon_putcs_physical_8 (struct display *p, const char *s,
  213. -                                     int count, int y, int x, int mode)
  214. +                                     int count, int y, int x, int attr)
  215.  {
  216.      register u_char   *dest, *cdat;
  217.      register ushort   rows, bytes;
  218. @@ -1586,8 +1613,7 @@
  219.           * d0 -- scratch  ; d1 -- count  ; d2 -- bytes
  220.           * 
  221.           */
  222. -    switch (mode) {
  223. -      case DM_COPY:
  224. +    if (!(attr & 0x8))
  225.          __asm__("movel  %1,d1   ; beq 5f      ; subqw #1,d1\n\t"
  226.              "movel  %0,a0   ; movel %2,a2\n\t"
  227.              "movel %3,a3;movel %4,d2\n\t"
  228. @@ -1611,8 +1637,7 @@
  229.              : "g" (dest0), "g" (count), "g" (s),
  230.              "g" (p->fontdata), "g" ((ulong) bytes)
  231.              : "a0", "a1", "a2", "a3", "d0", "d1", "d2");
  232. -        break;
  233. -      case DM_INVERSE:
  234. +    else
  235.          __asm__("movel  %1,d1   ; beq 5f      ; subqw #1,d1\n\t"
  236.              "movel  %0,a0   ; movel %2,a2\n\t"
  237.              "movel %3,a3;movel %4,d2\n\t"
  238. @@ -1636,8 +1661,6 @@
  239.              : "g" (dest0), "g" (count), "g" (s),
  240.              "g" (p->fontdata), "g" ((ulong) bytes)
  241.              : "a0", "a1", "a2", "a3", "d0", "d1", "d2", "d3");
  242. -        break;
  243. -    }
  244.      return;
  245.      }
  246.  #endif
  247. @@ -1663,25 +1686,22 @@
  248.  
  249.          cdat  = p->fontdata + (c * p->fontheight);
  250.          for (rows = p->fontheight ; rows-- ; dest += bytes)
  251. -        switch (mode) {
  252. -          case DM_COPY:
  253. +      if (!(attr & 8))
  254.          *dest = *cdat++;
  255. -        break;
  256. -          case DM_INVERSE:
  257. +      else
  258.          *dest = ~*cdat++;
  259. -        break;
  260. -        }
  261.      }
  262.  }
  263.  
  264.  static int amicon_putcs (struct condata *conp, const char *s,
  265. -                         int count, int y, int x, int mode)
  266. +                         int count, int y, int x)
  267.  {
  268. -    int unit = conp - vc_cons;
  269. +    int unit = 0;
  270. +    /*int unit = conp - vc_cons;*/
  271.      register struct display *p = &disp[unit];
  272.  
  273.      if (p->fontwidth == 8) {
  274. -        amicon_putcs_physical_8(p, s, count, real_y_8(p, y) , x, mode);
  275. +        amicon_putcs_physical_8(p, s, count, real_y_8(p, y) , x, conp->vc_attr);
  276.      } else {
  277.          /* Currently no support for (fontwidth != 8) */
  278.      }
  279. @@ -1692,7 +1712,8 @@
  280.  static int amicon_cursor (struct condata *conp,
  281.             int mode)
  282.  {
  283. -   int unit = conp - vc_cons;
  284. +   int unit=0;
  285. +   /*int unit = conp - vc_cons;*/
  286.     struct display *p = &disp[unit];
  287.  
  288.     if (mode == CM_ERASE) {
  289. @@ -1710,7 +1731,8 @@
  290.  static int amicon_scroll (struct condata *conp,
  291.                            int t, int b, int dir, int count)
  292.  {
  293. -    int unit                   = conp - vc_cons;
  294. +    int unit=0;
  295. +    /*int unit                   = conp - vc_cons;*/
  296.      register struct display *p = &disp[unit];
  297.  
  298.      amicon_cursor (conp, CM_ERASE);
  299. @@ -1773,6 +1795,21 @@
  300.  
  301.  static int amicon_switch (struct condata *conp)
  302.  {
  303. +  struct display *p = &disp[conp - vc_cons];
  304. +  struct display *old = &disp[fg_console];
  305. +
  306. +  if (!(conp->vc_flags & CON_INITED))
  307. +    return -1;
  308. +
  309. +  p->bitplane[0] = old->bitplane[0];    /* syncing the base address */
  310. +  p->bitplane[1] = old->bitplane[1];    /* syncing the base address */
  311. +  p->bitplane[2] = old->bitplane[2];    /* syncing the base address */
  312. +  p->bitplane[3] = old->bitplane[3];    /* syncing the base address */
  313. +  p->bitplane[4] = old->bitplane[4];    /* syncing the base address */
  314. +  p->bitplane[5] = old->bitplane[5];    /* syncing the base address */
  315. +  p->bitplane[6] = old->bitplane[6];    /* syncing the base address */
  316. +  p->bitplane[7] = old->bitplane[7];    /* syncing the base address */
  317. +
  318.      return 0;
  319.  }
  320.  
  321. @@ -1796,4 +1833,3 @@
  322.      amicon_init, amicon_deinit, amicon_clear, amicon_putc, amicon_putcs,
  323.      amicon_cursor, amicon_scroll, amicon_bmove, amicon_switch, amicon_blank
  324.  };
  325. -
  326. diff -ubr -x RCS -x *.[ao] -x .depend -x .version -x .config -x System.map -x vmlinux -x bootstrap -x *~ -x config.old -x *.orig -x *.rej -x *# -x version.h -x autoconf.h --new-file linux-0.9pl3/amiga/config.c linux-0.9pl4/amiga/config.c
  327. --- linux-0.9pl3/amiga/config.c    Sun Aug 14 10:29:40 1994
  328. +++ linux-0.9pl4/amiga/config.c    Sat Nov 12 09:16:52 1994
  329. @@ -66,25 +66,33 @@
  330.      lo    = ciab.talo;
  331.      hi2 = ciab.tahi;
  332.  
  333. -    if (hi != hi2)
  334. +    if (hi != hi2) {
  335.      lo = ciab.talo;
  336. +    hi = hi2;
  337. +    }
  338.  
  339.      ticks = hi << 8 | lo;
  340.  
  341.      if (boot_info.bi_amiga.eclock == NTSC_ECLOCK) {
  342. +#if 0 /* XXX */
  343. +/* reading the ICR clears all interrupts.  bad idea! */
  344.      if (ticks > NTSC_JIFFY_TICKS - NTSC_JIFFY_TICKS / 100)
  345.        /* check for pending interrupt */
  346.        if (ciab.icr & CIA_ICR_TA)
  347.          offset = 10000;
  348. +#endif
  349.      ticks = (NTSC_JIFFY_TICKS-1) - ticks;
  350. -    ticks = 10000 * ticks / NTSC_JIFFY_TICKS;
  351. +    ticks = (10000 * ticks) / NTSC_JIFFY_TICKS;
  352.      } else {
  353. +#if 0 /* XXX */
  354. +/* reading the ICR clears all interrupts.  bad idea! */
  355.      if (ticks > PAL_JIFFY_TICKS - PAL_JIFFY_TICKS / 100)
  356.        /* check for pending interrupt */
  357.        if (ciab.icr & CIA_ICR_TA)
  358.          offset = 10000;
  359. +#endif
  360.      ticks = (PAL_JIFFY_TICKS-1) - ticks;
  361. -    ticks = 10000 * ticks / NTSC_JIFFY_TICKS;
  362. +    ticks = (10000 * ticks) / NTSC_JIFFY_TICKS;
  363.      }
  364.  
  365.      return ticks + offset;
  366. @@ -194,21 +202,27 @@
  367.  
  368.  void amiga_reset (void)
  369.  {
  370. +  unsigned long jmp_addr040 = VTOP(&&jmp_addr_label040);
  371.      unsigned long jmp_addr = VTOP(&&jmp_addr_label);
  372.  
  373.      cli();
  374.      if (boot_info.cputype & CPU_68040)
  375. +    /* Setup transparent translation registers for mapping
  376. +     * of 16 MB kernel segment before disabling translation
  377. +     */
  378.      __asm__ __volatile__
  379. -        ("moveq #0,d0\n\t"
  380. -         "bra   2f\n\t"
  381. -         ".align 4\n\t"        /* align on cache line start */
  382. -         "2:\n\t"
  383. -         ".long 0x4e7b0003\n\t"    /* movec d0,tc */
  384. +      ("movel    %0,d0\n\t"
  385. +       "andl     #0xff000000,d0\n\t"
  386. +       "orw      #0xe020,d0\n\t"   /* map 16 MB, enable, cacheable */
  387. +       ".long    0x4e7b0004\n\t"   /* movec d0,itt0 */
  388. +       ".long    0x4e7b0006\n\t"   /* movec d0,dtt0 */
  389.           "jmp   %0@\n\t"
  390.           : /* no outputs */
  391. -         : "a" (jmp_addr)
  392. -         : "d0");
  393. +       : "a" (jmp_addr040));
  394.      else
  395. +    /* for 680[23]0, just disable translation and jump to the physical
  396. +     * address of the label
  397. +     */
  398.      __asm__ __volatile__
  399.          ("pmove  tc,sp@\n\t"
  400.           "bclr   #7,sp@\n\t"
  401. @@ -216,10 +230,21 @@
  402.           "jmp    %0@\n\t"
  403.           : /* no outputs */
  404.           : "a" (jmp_addr));
  405. + jmp_addr_label040:
  406. +  /* disable translation on '040 now */
  407. +  __asm__ __volatile__    
  408. +    ("moveq #0,d0\n\t"
  409. +     ".long 0x4e7b0003\n\t"         /* movec d0,tc; disable MMU */
  410. +     : /* no outputs */
  411. +     : /* no inputs */
  412. +     : "d0");
  413. +
  414.    jmp_addr_label:
  415. +  /* pickup reset address from AmigaOS ROM, reset devices and jump
  416. +   * to reset address
  417. +   */
  418.      __asm__ __volatile__
  419. -    ("movew #0x2700,sr\n\t"
  420. -     "leal  0x01000000,a0\n\t"
  421. +    ("leal  0x01000000,a0\n\t"
  422.       "subl  a0@(-0x14),a0\n\t"
  423.       "movel a0@(4),a0\n\t"
  424.       "subql #2,a0\n\t"
  425. @@ -231,4 +256,5 @@
  426.       "jmp   a0@");
  427.  
  428.      for (;;);
  429. +
  430.  }
  431. diff -ubr -x RCS -x *.[ao] -x .depend -x .version -x .config -x System.map -x vmlinux -x bootstrap -x *~ -x config.old -x *.orig -x *.rej -x *# -x version.h -x autoconf.h --new-file linux-0.9pl3/atari/atacon.c linux-0.9pl4/atari/atacon.c
  432. --- linux-0.9pl3/atari/atacon.c    Tue Sep 27 22:19:35 1994
  433. +++ linux-0.9pl4/atari/atacon.c    Mon Nov 21 18:08:54 1994
  434. @@ -37,14 +37,22 @@
  435.  #define    CONFIG_ATARI_8PLANE
  436.  #undef    CONFIG_ATARI_16PLANE
  437.  
  438. +/* If you do not work with X Windows, hardware scrolling may be
  439. + * nice...
  440. + */
  441. +#define HARDWARE_SCROLLING
  442. +
  443. +/* If you want to see underlined characters in color modes, define the
  444. + * following flag. But note that this effect cannot be restored when
  445. + * switching VC's!
  446. + */
  447. +#undef COLOR_UNDERLINING
  448. +
  449.  /* To do:
  450.   *
  451.   *  - Do proper Falcon video mode setting, analogous to the TT (but
  452.   *    much more and better modes possible!)
  453.   *  - Implement 16 plane mode.
  454. - *  - Do a backing store of characters and attributes on the screen
  455. - *    for conole switching (or will this be done in the device
  456. - *    independent part (console.c) ?)
  457.   *
  458.   */
  459.  
  460. @@ -76,7 +84,16 @@
  461.      fontname_8x16[], fontname_8x8[];
  462.  
  463.  
  464. +/* Import console_blanked from console.c */
  465. +
  466. +extern int console_blanked;
  467.  
  468. +/* This macro should return true, if in this mode the
  469. + * blanking/unblanking is done by blackening and redrawing the screen
  470. + */
  471. +#define REDRAW_BLANK_MODE(cons)                    \
  472. +    (boot_info.bi_atari.model == ATARI_TT &&    \
  473. +     disp[(cons)].shiftmode == TT_HIGH)
  474.  
  475.  
  476.  /* FONT_CNV does the character conversion necessary if the font
  477. @@ -93,25 +110,16 @@
  478.   *                                                             Roman
  479.   */
  480.  
  481. +/* ++andreas: Translation now done in console.c */
  482. +
  483.  #ifndef WHOLE_FONT
  484.  
  485. -#define    FONT_CNV(c) ({
  486. -   int __rv = 1;
  487. -   if ((c >= 32) && (c < 127))
  488. -       /* lower half of charset -- normal ASCII */
  489. -       c -=  32;
  490. -    else if ((c >= 160) && (c < 255))
  491. -        /* upper half of charset -- special characters */
  492. -        c -= 64;
  493. -    else
  494. -        /* not defined in charset -- non-printable character */
  495. -        __rv = 0;
  496. -   __rv;
  497. -})
  498. +#define    FONT_CNV(c) (((c) -= 32) >= 0 \
  499. +             && ((c) <= 127 - 32 || ((c) -= 32) >= 160 - 64))
  500.  
  501.  #else
  502.  
  503. -#define    FONT_CNV(c) ((c = conp->vc_translate[c]) != 0)
  504. +#define    FONT_CNV(c) (1)
  505.  
  506.  #endif
  507.  
  508. @@ -140,9 +148,9 @@
  509.      void (*clear)( struct condata *conp, register struct display *p,
  510.                     int sy, int sx, int height, int width);
  511.      void (*putc)( struct condata *conp, struct display *p, int c,
  512. -                  int y, int x, int mode );
  513. +                  int y, int x);
  514.      void (*putcs)( struct condata *conp, struct display *p,
  515. -                   const char *s, int count, int y, int x, int mode);
  516. +                   const char *s, int count, int y, int x);
  517.      void (*rev_char)( struct display *display, int x, int y );
  518.  };    
  519.  
  520. @@ -165,9 +173,11 @@
  521.      u_char *bitplane;            /* pointer to display bitmap; planes
  522.                                   * are interleaved!
  523.                                   */
  524. +#ifdef HARDWARE_SCROLLING
  525.      u_char *screen_base;    /* Base of display bitmap for hardware
  526.                     scrolling */
  527.      u_char *screen_end;        /* End of first half of display bitmap */
  528. +#endif
  529.  
  530.      u_long *color_map;          /* XXX Not yet implemented XXX */
  531.  
  532. @@ -193,10 +203,13 @@
  533.      { "ttlow",   320 , 480 , 8 } };            /* TT-Low */
  534.      
  535.  static struct tt_vid_type falcon_video_modes[] = {
  536. +    { "sthigh",    640 , 400 , 1 } ,        /* ST-High */
  537.      { "vga16",   640 , 480 , 4 } ,            /* VGA 16 colors */
  538.      { "vga4",    640 , 480 , 2 } ,            /* VGA 4 colors */
  539.      { "vga2",    640 , 480 , 1 } ,            /* VGA 2 colors */
  540. -    { "vga256",  640 , 480 , 8 }             /* VGA 256 colors */
  541. +    { "vga256",  640 , 480 , 8 } ,            /* VGA 256 colors */
  542. +    { "falh2",   896 , 608 , 1 } ,            /* hires for sblaster */
  543. +    { "falh16",  896 , 608 , 4 }             /* hires for sblaster */
  544.  };
  545.  
  546.  /* Default color maps for 4 and 2 plane modes. These use the PC-ish
  547. @@ -291,7 +304,7 @@
  548.  
  549.  static void detect_video (int *yres, int *xres, int *depth, int *shiftmode);
  550.  static int shifter_init( u_long adr);
  551. -static long atacon_init( struct condata *conp, long mem_start);
  552. +static long atacon_init( struct condata *conp, long mem_start, char **display_desc);
  553.  static int atacon_deinit( struct condata *conp);
  554.  static __inline__ void *mymemclear_small( void * s, size_t count);
  555.  static __inline__ void *mymemclear( void * s, size_t count);
  556. @@ -323,10 +336,9 @@
  557.                           dx, int height, int width);
  558.  static int atacon_clear( struct condata *conp, int sy, int sx, int height,
  559.                           int width);
  560. -static int atacon_putc( struct condata *conp, int c, int y, int x, int
  561. -                        mode);
  562. +static int atacon_putc( struct condata *conp, int c, int y, int x);
  563.  static int atacon_putcs( struct condata *conp, const char *s, int count,
  564. -                         int y, int x, int mode);
  565. +                         int y, int x);
  566.  static int atacon_scroll( struct condata *conp, int t, int b, int dir, int
  567.                            count);
  568.  static int atacon_switch( struct condata *conp);
  569. @@ -337,12 +349,10 @@
  570.                                    display *p, int sy, int sx, int height,
  571.                                    int width );
  572.  static void atacon_putc_1_plane( struct condata *conp, struct display *p,
  573. -                                 int c, int y, int x, int mode);
  574. +                                 int c, int y, int x);
  575.  static void atacon_putcs_1_plane( struct condata *conp, struct display *p,
  576. -                                  const char *s, int count, int y, int x,
  577. -                                  int mode);
  578. -static void atacon_rev_char_1_plane( struct display *display, int x, int y
  579. -                                     );
  580. +                                  const char *s, int count, int y, int x);
  581. +static void atacon_rev_char_1_plane( struct display *display, int x, int y );
  582.  #ifdef CONFIG_ATARI_2PLANE
  583.  static void atacon_bmove_2_plane( register struct display *p, int sy, int
  584.                                    sx, int dy, int dx, int height, int
  585. @@ -351,12 +361,10 @@
  586.                                    display *p, int sy, int sx, int height,
  587.                                    int width );
  588.  static void atacon_putc_2_plane( struct condata *conp, struct display *p,
  589. -                                 int c, int y, int x, int mode);
  590. +                                 int c, int y, int x);
  591.  static void atacon_putcs_2_plane( struct condata *conp, struct display *p,
  592. -                                  const char *s, int count, int y, int x,
  593. -                                  int mode);
  594. -static void atacon_rev_char_2_plane( struct display *display, int x, int y
  595. -                                     );
  596. +                                  const char *s, int count, int y, int x);
  597. +static void atacon_rev_char_2_plane( struct display *display, int x, int y );
  598.  #endif
  599.  #ifdef CONFIG_ATARI_4PLANE
  600.  static void atacon_bmove_4_plane( register struct display *p, int sy, int
  601. @@ -366,12 +374,10 @@
  602.                                    display *p, int sy, int sx, int height,
  603.                                    int width );
  604.  static void atacon_putc_4_plane( struct condata *conp, struct display *p,
  605. -                                 int c, int y, int x, int mode);
  606. +                                 int c, int y, int x);
  607.  static void atacon_putcs_4_plane( struct condata *conp, struct display *p,
  608. -                                  const char *s, int count, int y, int x,
  609. -                                  int mode);
  610. -static void atacon_rev_char_4_plane( struct display *display, int x, int y
  611. -                                     );
  612. +                                  const char *s, int count, int y, int x);
  613. +static void atacon_rev_char_4_plane( struct display *display, int x, int y );
  614.  #endif
  615.  #ifdef CONFIG_ATARI_8PLANE
  616.  static void atacon_bmove_8_plane( register struct display *p, int sy, int
  617. @@ -381,12 +387,10 @@
  618.                                    display *p, int sy, int sx, int height,
  619.                                    int width );
  620.  static void atacon_putc_8_plane( struct condata *conp, struct display *p,
  621. -                                 int c, int y, int x, int mode);
  622. +                                 int c, int y, int x);
  623.  static void atacon_putcs_8_plane( struct condata *conp, struct display *p,
  624. -                                  const char *s, int count, int y, int x,
  625. -                                  int mode);
  626. -static void atacon_rev_char_8_plane( struct display *display, int x, int y
  627. -                                     );
  628. +                                  const char *s, int count, int y, int x);
  629. +static void atacon_rev_char_8_plane( struct display *display, int x, int y );
  630.  #endif
  631.  #ifdef CURSOR_DELAY_TIMER
  632.  static void atacon_curtimfunc( unsigned long _disp );
  633. @@ -601,8 +605,9 @@
  634.      }
  635.   }
  636.  
  637. -static int shifter_init(u_long adr)
  638. +static int shifter_init(u_long vadr)
  639.   {
  640. +  u_long adr = VTOP(vadr);
  641.  /* Setup Screen Memory */
  642.    shifter.bas_hi=(u_char)((adr & 0xff0000) >> 16);
  643.    shifter.bas_md=(u_char)((adr & 0x00ff00) >> 8);
  644. @@ -611,12 +616,16 @@
  645.   }
  646.  
  647.  
  648. -static long atacon_init(struct condata *conp, long mem_start)
  649. +static long atacon_init(struct condata *conp, long mem_start, char **display_desc)
  650.  {
  651.      int unit = conp - vc_cons;    
  652.      unsigned long mem_req;
  653.      u_char *screen_base;
  654. +    static int master_init = 0;
  655. +    static char mode_name[40];
  656.  
  657. +    if (!master_init) {
  658. +        master_init = 1;
  659.      /* set up the display defaults */
  660.      detect_video( &disp[unit].scr_height, &disp[unit].scr_width,
  661.                    &disp[unit].scr_depth, &disp[unit].shiftmode );
  662. @@ -684,31 +693,76 @@
  663.          panic( "atacon_init: %d planes not supported.\n",
  664.                 disp[unit].scr_depth );
  665.      
  666. -    conp->vc_cols = disp[unit].scr_width / disp[unit].fontwidth;
  667. -    conp->vc_rows = disp[unit].scr_height / disp[unit].fontheight;
  668.  
  669. +#ifdef HARDWARE_SCROLLING
  670. +        /* For hardware scrolling, allocate twice the memory we'd need for
  671. +         * one screen.
  672. +         * The base is rounded up to the next multiple of 8.
  673. +         */
  674.      mem_req = (disp[unit].scr_width/8)*disp[unit].scr_height*
  675.                disp[unit].scr_depth;
  676. -    /* locate the bitplane */
  677. -    /* GK: why allocate 2*mem_req ???? */
  678. -    screen_base = atari_stram_alloc (mem_req * 2 + 8);
  679. +        screen_base = atari_stram_alloc (mem_req * 2 + 8, &mem_start );
  680.      screen_base = (u_char *) (((u_long) screen_base + 7) & ~7);
  681. -    disp[unit].screen_base = disp[unit].bitplane = screen_base;
  682. +        disp[unit].screen_base = screen_base;
  683.      disp[unit].screen_end = screen_base + mem_req;
  684. +#else
  685. +        /* If hardware scrolling is disabled, but support for X should
  686. +         * come up, allocate the screen mem page-aligned... (begin and end!)
  687. +         */
  688. +        mem_req = (disp[unit].scr_width/8)*disp[unit].scr_height*
  689. +            disp[unit].scr_depth;
  690. +        mem_req = ((mem_req + PAGE_SIZE - 1) & PAGE_MASK) + PAGE_SIZE;
  691. +        screen_base = atari_stram_alloc( mem_req, &mem_start );
  692. +        screen_base = (u_char *) (((u_long)screen_base + PAGE_SIZE - 1) & PAGE_MASK);
  693. +#endif
  694. +        disp[unit].bitplane = screen_base;
  695.      memset (screen_base, 0, mem_req);
  696.  
  697.      shifter_init ((unsigned long)screen_base);
  698.      
  699. +        switch( boot_info.bi_atari.model ) {
  700. +              case ATARI_TT:
  701. +            strcpy( mode_name, "TT native " );
  702. +            strcat( mode_name, tt_video_modes[disp[unit].shiftmode].name );
  703. +            break;
  704. +              case ATARI_FALCON:
  705. +            strcpy( mode_name, "Falcon native " );
  706. +            strcat( mode_name, falcon_video_modes[disp[unit].shiftmode].name );
  707. +            break;
  708. +              default:
  709. +            strcpy( mode_name, "unknown Atari graphics" );
  710. +            break;
  711. +        }
  712. +        *display_desc = mode_name;
  713.  
  714.  #ifdef CURSOR_DELAY_VBL
  715.      add_isr( IRQ4, atacon_vbl_handler, 0, NULL );
  716.  #endif
  717. +    }
  718. +    else
  719. +        /* Copy all from the first console, maybe allow different
  720. +           display modes later. */
  721. +        disp[unit] = disp[0];
  722. +    
  723. +    conp->vc_cols = disp[unit].scr_width / disp[unit].fontwidth;
  724. +    conp->vc_rows = disp[unit].scr_height / disp[unit].fontheight;
  725. +    conp->vc_flags |= CON_INITED;
  726. +    conp->vc_can_do_color = disp[unit].scr_depth != 1;
  727.      
  728.      return mem_start;
  729.  }
  730.  
  731.  static int atacon_deinit (struct condata *conp)
  732.  {
  733. +  struct display *p = &disp[conp - vc_cons];
  734. +
  735. +  /* You can't deinit a non inited screen nor the console 0. */
  736. +  if (!(conp->vc_flags & CON_INITED) || p == disp)
  737. +    return -1;
  738. +
  739. +  atacon_switch (&vc_cons[0]);    /* Always switch to the console 0 */
  740. +  memset (p, 0, sizeof (struct display));
  741. +  conp->vc_flags &= ~CON_INITED;
  742.      return 0;
  743.  }
  744.  
  745. @@ -821,6 +875,28 @@
  746.      return(0);              
  747.  }
  748.  
  749. +static __inline__ void *mymemset(void * s, size_t count)
  750. +
  751. +{
  752. +  if (!count) return(0);
  753. +  
  754. +  __asm__ __volatile__
  755. +    ("lsrl   #1,%1 ; jcc 1f ; moveb %2,%0@-\n\t"
  756. +     "1: lsrl   #1,%1 ; jcc 1f ; movew %2,%0@-\n\t"
  757. +     "1: lsrl   #1,%1 ; jcc 1f ; movel %2,%0@-\n\t"
  758. +     "1: lsrl   #1,%1 ; jcc 1f ; movel %2,%0@- ; movel %2,%0@-\n\t"
  759. +     "1: subql  #1,%1 ; jcs 3f\n\t"
  760. +     "2: moveml %2/%3/%4/%5,%0@-\n\t"
  761. +     "dbra %1,2b\n\t"
  762. +     "3:"
  763. +     : "=a" (s), "=d" (count)
  764. +     :  "d" (-1), "d" (-1), "d" (-1), "d" (-1),
  765. +     "0" ((char *) s + count), "1" (count)
  766. +     );
  767. +  
  768. +  return(0);              
  769. +}
  770. +
  771.  static __inline__ void *mymemmove(void * d, void * s, size_t count)
  772.  {
  773.      if (d < s) {
  774. @@ -1384,6 +1460,9 @@
  775.      int unit = conp - vc_cons;
  776.      struct display *p = &disp[unit];
  777.      
  778. +    if (REDRAW_BLANK_MODE(unit) && console_blanked)
  779. +        return( 0 );
  780. +    
  781.      if ((sy <= p->cursor_y && p->cursor_y < sy+height &&
  782.           sx <= p->cursor_x && p->cursor_x < sx+width)   ||
  783.          (dy <= p->cursor_y && p->cursor_y < dy+height &&
  784. @@ -1400,6 +1479,9 @@
  785.      int unit = conp - vc_cons;
  786.      register struct display *p = &disp[unit];
  787.  
  788. +    if (REDRAW_BLANK_MODE(unit) && console_blanked)
  789. +        return( 0 );
  790. +    
  791.      if (sy <= p->cursor_y && p->cursor_y < sy+height &&
  792.          sx <= p->cursor_x && p->cursor_x < sx+width)
  793.          CURSOR_UNDRAWN();
  794. @@ -1409,31 +1491,36 @@
  795.      return(0);
  796.  }
  797.  
  798. -static int atacon_putc (struct condata *conp,
  799. -                        int c, int y, int x, int mode)
  800. +static int atacon_putc (struct condata *conp, int c, int y, int x)
  801.  {
  802.      int unit = conp - vc_cons;
  803.      register struct display *p = &disp[unit];
  804.  
  805. +    if (REDRAW_BLANK_MODE(unit) && console_blanked)
  806. +        return( 0 );
  807. +    
  808.      if (p->cursor_x == x && p->cursor_y == y)
  809.          CURSOR_UNDRAWN();
  810.      
  811. -    p->dispsw->putc( conp, p, c, y, x, mode );
  812. +    p->dispsw->putc( conp, p, c, y, x );
  813.  
  814.      return(0);
  815.  }
  816.  
  817.  static int atacon_putcs (struct condata *conp, const char *s,
  818. -                         int count, int y, int x, int mode)
  819. +                         int count, int y, int x)
  820.  {
  821.      int unit = conp - vc_cons;
  822.      register struct display *p = &disp[unit];
  823.  
  824. +    if (REDRAW_BLANK_MODE(unit) && console_blanked)
  825. +        return( 0 );
  826. +    
  827.      if (p->cursor_y == y &&
  828.          x <= p->cursor_x && p->cursor_x < x+count)
  829.          CURSOR_UNDRAWN();
  830.      
  831. -    p->dispsw->putcs( conp, p, s, count, y, x, mode );
  832. +    p->dispsw->putcs( conp, p, s, count, y, x );
  833.  
  834.      return(0);
  835.  }
  836. @@ -1442,9 +1529,13 @@
  837.  static int atacon_scroll (struct condata *conp,
  838.                            int t, int b, int dir, int count)
  839.  {
  840. +    if (REDRAW_BLANK_MODE(conp-vc_cons) && console_blanked)
  841. +        return( 0 );
  842. +    
  843.      switch (dir) {
  844.  
  845.      case SM_UP:
  846. +#ifdef HARDWARE_SCROLLING
  847.        /* Use hardware scrolling if possible */
  848.        if (t == 0 && b == conp->vc_rows)
  849.      {
  850. @@ -1464,12 +1555,14 @@
  851.        shifter_init ((u_long) p->bitplane);
  852.      }
  853.        else
  854. +#endif
  855.          atacon_bmove( conp, t + count, 0, t, 0,
  856.                        (b-t-count), conp->vc_cols );
  857.          atacon_clear( conp, b-count, 0, count, conp->vc_cols );
  858.          break;
  859.  
  860.      case SM_DOWN:
  861. +#ifdef HARDWARE_SCROLLING
  862.        /* Use hardware scrolling if possible */
  863.        if (t == 0 && b == conp->vc_rows)
  864.      {
  865. @@ -1490,6 +1583,7 @@
  866.        shifter_init ((u_long) p->bitplane);
  867.      }
  868.        else
  869. +#endif
  870.          atacon_bmove( conp, t, 0, t+count, 0,
  871.                        (b-t-count), conp->vc_cols );
  872.  
  873. @@ -1519,11 +1613,61 @@
  874.  
  875.  static int atacon_switch (struct condata *conp)
  876.  {
  877. +#ifdef HARDWARE_SCROLLING
  878. +  struct display *p = &disp[conp - vc_cons];
  879. +  struct display *old = &disp[fg_console];
  880. +#endif
  881. +
  882. +  if (!(conp->vc_flags & CON_INITED))
  883. +    return -1;
  884. +
  885. +#ifdef HARDWARE_SCROLLING
  886. +  p->bitplane = old->bitplane;    /* syncing the base address */
  887. +#endif
  888.      return 0;
  889.  }
  890.  
  891.  static int atacon_blank (int blank)
  892.  {
  893. +  static u_short saved_tt_palette[256];
  894. +  int i;
  895. +
  896. +  if (boot_info.bi_atari.model != ATARI_TT)
  897. +    return 0;
  898. +
  899. +  atacon_cursor( &vc_cons[fg_console], blank ? CM_ERASE : CM_DRAW );
  900. +  
  901. +  if (REDRAW_BLANK_MODE(fg_console)) {
  902. +    /* Special treatment for TT High mode: Changing the palette
  903. +     * registers isn't possible, so the screen is filled with black
  904. +     * for blanking and completely restored for unblanking.
  905. +     */
  906. +    if (blank) {
  907. +        struct display *p = &disp[fg_console];
  908. +        mymemset( p->bitplane, p->bytes_per_row * p->scr_height );
  909. +        return( 0 );
  910. +    }
  911. +    else {
  912. +        /* Tell console.c that it has to completely restore the
  913. +         * screen itself
  914. +         */
  915. +        return( 1 );
  916. +    }
  917. +  }
  918. +
  919. +  if (blank)
  920. +    {
  921. +      for (i = 0; i < 256; i++)
  922. +    {
  923. +      saved_tt_palette[i] = tt_palette[i];
  924. +      tt_palette[i] = 0;
  925. +    }
  926. +    }
  927. +  else
  928. +    {
  929. +      for (i = 0; i < 256; i++)
  930. +    tt_palette[i] = saved_tt_palette[i];
  931. +    }
  932.      return 0;
  933.  }
  934.  
  935. @@ -1596,8 +1740,29 @@
  936.  }
  937.  
  938.  
  939. +/* The text effects (bold, reverse, light, underlined, blink) are represented
  940. + * in the attribute byte as follows: (like a monochrome PC graphics adapter):
  941. + * 
  942. + *  - (attr & 0x80) == 0x00 =>  not blinking
  943. + *                  == 0x80 =>  blinking (not implemented, ignored)
  944. + *  - (attr & 0x70) != 0    =>  reverse
  945. + *                  == 0    =>  not reverse
  946. + *  - (attr & 0x03) == 0x01 =>  underlined
  947. + *                  != 0x01 =>  not underlined
  948. + *  - (attr & 0x08) == 0    =>  normal intensity
  949. + *    (attr & 0x08) != 0 && (attr & 0x77) == 0 => light (half intensity)
  950. + *                                        != 0 => bright (bold, double intensity)
  951. + *
  952. + * Note that several combinations of effects are not possible with
  953. + * that representation. Light mode isn't possible if underlined and/or
  954. + * reverse mode are active. Characters are printed bright in that
  955. + * cases instead of light :-( Maybe the representation should be
  956. + * changed (separate bits for each effect)...
  957. + *
  958. + */
  959. +
  960.  static void atacon_putc_1_plane( struct condata *conp, struct display *p,
  961. -                                 int c, int y, int x, int mode)
  962. +                                 int c, int y, int x)
  963.  {
  964.      register u_char   *dest;
  965.      register u_char   *cdat;
  966. @@ -1613,28 +1778,27 @@
  967.      dest  = p->bitplane + offset;
  968.      cdat  = p->fontdata + (c * p->fontheight);
  969.  
  970. -    if (conp->vc_intensity != 1 || conp->vc_reverse ^ conp->vc_decscnm) {
  971. +    if ((conp->vc_attr & 0x0b) != 0x01) {
  972.          register u_char    andmask, xormask, c;
  973.          register int    bold;
  974.          
  975. -        andmask = (conp->vc_intensity == 0) ? 0x55 : 0xff;
  976. -        xormask = (conp->vc_reverse ^ conp->vc_decscnm) ? 0xff : 0;
  977. -        bold = (conp->vc_intensity == 2);
  978. +      xormask = (conp->vc_attr & 0x08) ? 0xff : 0;           /* reverse */
  979. +      andmask = ((conp->vc_attr & 0x03) == 0) ? 0x55 : 0xff; /* light */
  980. +      bold    = ((conp->vc_attr & 0x03) == 2);               /* bold/bright */
  981.          
  982.          for (rows = p->fontheight ; rows-- ; dest += bytes) {
  983.              c = *cdat++;
  984. -            if (rows == 0 && conp->vc_underline) c = 0xff;
  985. +    if (rows == 0 && (conp->vc_attr & 0x04)) c = 0xff;
  986.              c = (c & andmask) ^ xormask;
  987.              if (bold) c |= c >> 1;
  988.              *dest = c;
  989.          }
  990.      }
  991.      else {
  992. -        
  993.          for (rows = p->fontheight ; rows-- ; dest += bytes)
  994.              *dest = *cdat++;
  995.  
  996. -        if (conp->vc_underline)
  997. +      if (conp->vc_attr & 0x04) /* underlined */
  998.              dest[-bytes] ^= ~0;
  999.      }
  1000.  }
  1001. @@ -1642,15 +1806,14 @@
  1002.  
  1003.  static void atacon_putcs_1_plane( struct condata *conp, struct
  1004.                                    display *p, const char *s,
  1005. -                                  int count, int y, int x, int mode)
  1006. +                                  int count, int y, int x)
  1007.  {
  1008.      register u_char   *dest, *cdat;
  1009.      register int rows, bytes;
  1010.      register u_char   c;
  1011.      u_char   *dest0;
  1012.      ulong    offset;
  1013. -    int         effects = (conp->vc_underline || conp->vc_intensity != 1 ||
  1014. -                        (conp->vc_reverse ^ conp->vc_decscnm));
  1015. +    int      effects = (conp->vc_attr & 0x0f) != 0x01;
  1016.      
  1017.      if (!count) return;
  1018.      
  1019. @@ -1721,9 +1884,9 @@
  1020.          register u_char    andmask, xormask, ch;
  1021.          register int    bold;
  1022.          
  1023. -        andmask = (conp->vc_intensity == 0) ? 0x55 : 0xff;
  1024. -        xormask = (conp->vc_reverse ^ conp->vc_decscnm) ? 0xff : 0;
  1025. -        bold = (conp->vc_intensity == 2);
  1026. +        xormask = (conp->vc_attr & 0x08) ? 0xff : 0;
  1027. +        andmask = ((conp->vc_attr & 0x03) == 0) ? 0x55 : 0xff;
  1028. +        bold = ((conp->vc_attr & 0x03) == 2);
  1029.  
  1030.          while (count--) {
  1031.              c = *(s++);
  1032. @@ -1734,7 +1897,7 @@
  1033.  
  1034.              for (rows = p->fontheight ; rows-- ; dest += bytes) {
  1035.                  ch = *cdat++;
  1036. -                if (rows == 0 && conp->vc_underline) ch = 0xff;
  1037. +                if (rows == 0 && (conp->vc_attr & 0x04)) ch = 0xff;
  1038.                  ch = (ch & andmask) ^ xormask;
  1039.                  if (bold) ch |= ch >> 1;
  1040.                  *dest = ch;
  1041. @@ -1972,7 +2135,7 @@
  1042.  
  1043.  
  1044.  static void atacon_putc_2_plane( struct condata *conp, struct display *p,
  1045. -                                 int c, int y, int x, int mode)
  1046. +                                 int c, int y, int x)
  1047.  
  1048.  {    register u_char   *dest;
  1049.      register u_char   *cdat;
  1050. @@ -1996,16 +2159,19 @@
  1051.                                 : "a" (dest), "d" ((fdx & eorx) ^ bgx) );
  1052.      }
  1053.  
  1054. +
  1055. +#ifdef COLOR_UNDERLINING
  1056.      if (conp->vc_underline) {
  1057.          __asm__ __volatile__ ( "movepw %1,%0@(0)" : /* no outputs */
  1058.                                 : "a" (dest-bytes), "d" (fgx) );
  1059.      }
  1060. +#endif
  1061.  }
  1062.  
  1063.  
  1064.  static void atacon_putcs_2_plane( struct condata *conp, struct
  1065.                                    display *p, const char *s,
  1066. -                                  int count, int y, int x, int mode)
  1067. +                                  int count, int y, int x)
  1068.  
  1069.  {    register u_char   *dest, *dest0;
  1070.      register u_char   *cdat, c;
  1071. @@ -2031,10 +2197,12 @@
  1072.                                     : "a" (dest), "d" ((fdx & eorx) ^ bgx) );
  1073.          }
  1074.  
  1075. +#ifdef COLOR_UNDERLINING
  1076.          if (conp->vc_underline) {
  1077.              __asm__ __volatile__ ( "movepw %1,%0@(0)" : /* no outputs */
  1078.                                     : "a" (dest-bytes), "d" (fgx) );
  1079.          }
  1080. +#endif
  1081.  
  1082.          INC_2P(dest0);
  1083.      }
  1084. @@ -2255,7 +2423,7 @@
  1085.  
  1086.  
  1087.  static void atacon_putc_4_plane( struct condata *conp, struct display *p,
  1088. -                                 int c, int y, int x, int mode)
  1089. +                                 int c, int y, int x)
  1090.  {    register u_char   *dest;
  1091.      register u_char   *cdat;
  1092.      register int rows;
  1093. @@ -2278,16 +2446,18 @@
  1094.                                 : "a" (dest), "d" ((fdx & eorx) ^ bgx) );
  1095.      }
  1096.  
  1097. +#ifdef COLOR_UNDERLINING
  1098.      if (conp->vc_underline) {
  1099.          __asm__ __volatile__ ( "movepl %1,%0@(0)" : /* no outputs */
  1100.                                 : "a" (dest-bytes), "d" (fgx) );
  1101.      }
  1102. +#endif
  1103.  }
  1104.  
  1105.  
  1106.  static void atacon_putcs_4_plane( struct condata *conp, struct
  1107.                                    display *p, const char *s,
  1108. -                                  int count, int y, int x, int mode)
  1109. +                                  int count, int y, int x)
  1110.  {    register u_char   *dest, *dest0;
  1111.      register u_char   *cdat, c;
  1112.      register int rows;
  1113. @@ -2319,10 +2489,12 @@
  1114.                                     : "a" (dest), "d" ((fdx & eorx) ^ bgx) );
  1115.          }
  1116.  
  1117. +#ifdef COLOR_UNDERLINING
  1118.          if (conp->vc_underline) {
  1119.              __asm__ __volatile__ ( "movepl %1,%0@(0)" : /* no outputs */
  1120.                                     : "a" (dest-bytes), "d" (fgx) );
  1121.          }
  1122. +#endif
  1123.  
  1124.          INC_4P(dest0);
  1125.      }
  1126. @@ -2554,7 +2726,7 @@
  1127.  
  1128.  
  1129.  static void atacon_putc_8_plane( struct condata *conp, struct display *p,
  1130. -                                 int c, int y, int x, int mode)
  1131. +                                 int c, int y, int x)
  1132.  {    register u_char   *dest;
  1133.      register u_char   *cdat;
  1134.      register int rows;
  1135. @@ -2582,6 +2754,7 @@
  1136.              );
  1137.      }
  1138.  
  1139. +#ifdef COLOR_UNDERLINING
  1140.      if (conp->vc_underline) {
  1141.          __asm__ __volatile__
  1142.              ( "movepl %1,%0@(0)\n\t"
  1143. @@ -2590,12 +2763,13 @@
  1144.                : "a" (dest-bytes), "d" (fgx1), "d" (fgx2)
  1145.              );
  1146.      }
  1147. +#endif
  1148.  }
  1149.  
  1150.  
  1151.  static void atacon_putcs_8_plane( struct condata *conp, struct
  1152.                                    display *p, const char *s,
  1153. -                                  int count, int y, int x, int mode)
  1154. +                                  int count, int y, int x)
  1155.  
  1156.  {    register u_char   *dest, *dest0;
  1157.      register u_char   *cdat, c;
  1158. @@ -2634,6 +2808,7 @@
  1159.                  );
  1160.          }
  1161.  
  1162. +#ifdef COLOR_UNDERLINING
  1163.          if (conp->vc_underline) {
  1164.              __asm__ __volatile__
  1165.                  ( "movepl %1,%0@(0)\n\t"
  1166. @@ -2642,6 +2817,7 @@
  1167.                    : "a" (dest-bytes), "d" (fgx1), "d" (fgx2)
  1168.                  );
  1169.          }
  1170. +#endif
  1171.  
  1172.          INC_8P(dest0);
  1173.      }
  1174. diff -ubr -x RCS -x *.[ao] -x .depend -x .version -x .config -x System.map -x vmlinux -x bootstrap -x *~ -x config.old -x *.orig -x *.rej -x *# -x version.h -x autoconf.h --new-file linux-0.9pl3/atari/ataints.c linux-0.9pl4/atari/ataints.c
  1175. --- linux-0.9pl3/atari/ataints.c    Thu Sep 29 20:15:49 1994
  1176. +++ linux-0.9pl4/atari/ataints.c    Mon Nov 21 18:08:55 1994
  1177. @@ -51,24 +51,29 @@
  1178.  
  1179.  /* GK:
  1180.   * HBL IRQ handler for Falcon. Nobody needs it :-)
  1181. + * ++andreas: raise ipl to disable further interrupts.
  1182.   */
  1183.  asmlinkage void falcon_hblhandler(void);
  1184.  asm(".text
  1185. -     _falcon_hblhandler: rte");
  1186. +_falcon_hblhandler:
  1187. +    moveml    d0/a0,sp@-
  1188. +    btst    #4,sp@(14)    /* throwaway frame? */
  1189. +    beq    1f
  1190. +    movec    msp,a0        /* yes, use master stack */
  1191. +    bra    2f
  1192. +1:    lea    sp@(8),a0    /* else, use interrupt stack */
  1193. +2:    movew    a0@,d0
  1194. +    andw    #0xf8ff,d0
  1195. +    orw    #0x0200,d0    /* set saved ipl to 2 */
  1196. +    movew    d0,a0@
  1197. +    moveml    sp@+,d0/a0
  1198. +    rte");
  1199.  
  1200.  extern void atari_microwire_cmd( int cmd );
  1201.  
  1202.  void atari_init_INTS (void)
  1203.  
  1204.  {
  1205. -    int i;
  1206. -
  1207. -     /* GK: BSS is not cleared by bootstrap, so we must explicitly
  1208. -      * initialize the interrupt sources list
  1209. -      */
  1210. -     for( i = 0; i < NUM_ATARI_SOURCES; ++i )
  1211. -         ata_lists[i] = 0;
  1212. -    
  1213.      /* Initialize the MFP(s) */
  1214.      
  1215.      mfp.vec_adr  = 0x48;    /* Software EOI-Mode */
  1216. @@ -153,11 +158,37 @@
  1217.    return 1;
  1218.  }
  1219.  
  1220. +#if 0
  1221. +
  1222. +#include <linux/mm.h>
  1223. +extern unsigned long RCont;
  1224. +
  1225. +#define TEST_PAGE(str,adr)                                    \
  1226. +    do {                                                    \
  1227. +        unsigned long flags;                                \
  1228. +        save_flags(flags);; cli();                            \
  1229. +        if (*(unsigned long *)0xc03ff000 != RCont) {        \
  1230. +            printk("*0xc03ff000 = %08lx mem_map[]=%d\n",    \
  1231. +                   (RCont = *(unsigned long *)0xc03ff000),    \
  1232. +                   mem_map[MAP_NR(0xc03ff000)] );            \
  1233. +            printk("%s ",(str));                            \
  1234. +            printk("%08lx\n",(unsigned long)(adr));            \
  1235. +        }                                                    \
  1236. +        restore_flags(flags);                                \
  1237. +    } while(0)
  1238. +
  1239. +#else
  1240. +
  1241. +#define TEST_PAGE(str,adr) do {} while(0)
  1242. +
  1243. +#endif
  1244. +
  1245.  void atari_process_int (int level, struct intframe *fp)
  1246.  {
  1247.    ushort sr;
  1248.    int mask;
  1249.  
  1250. +TEST_PAGE("start irq level",level);
  1251.    /* Lower the ipl to let interrupts with higher priority come through */
  1252.    asm volatile ("movew sr,%0" : "=dm" (sr));
  1253.    sr -= 0x100;
  1254. @@ -168,6 +199,11 @@
  1255.  
  1256.    call_isr_list (ata_lists[level], fp);
  1257.  
  1258. +  /* Raise ipl again to avoid stacked interrupts.  */
  1259. +  asm volatile ("movew sr,%0" : "=dm" (sr));
  1260. +  sr += 0x100;
  1261. +  asm volatile ("movew %0,sr" : : "dm" (sr));
  1262. +
  1263.    /* acknowledge the interrupt */
  1264.    mask = ~(1 << (level & 7));
  1265.    switch (level >> 3)
  1266. @@ -186,7 +222,7 @@
  1267.        break;
  1268.      case 4:
  1269.      case 5:
  1270. -      /* TODO: SCC interrupt acknowledge */
  1271. +      scc.cha_a_ctrl = 070;    /* Reset highest IUS */
  1272.        break;
  1273.      }
  1274.  }
  1275. diff -ubr -x RCS -x *.[ao] -x .depend -x .version -x .config -x System.map -x vmlinux -x bootstrap -x *~ -x config.old -x *.orig -x *.rej -x *# -x version.h -x autoconf.h --new-file linux-0.9pl3/atari/atakeyb.c linux-0.9pl4/atari/atakeyb.c
  1276. --- linux-0.9pl3/atari/atakeyb.c    Sun Aug 14 10:30:00 1994
  1277. +++ linux-0.9pl4/atari/atakeyb.c    Mon Nov  7 22:07:47 1994
  1278. @@ -35,18 +35,26 @@
  1279.  /*
  1280.   * ++roman: The following changes were applied manually:
  1281.   *
  1282. - *  - The Alt (= Meta) key works in combination with Shift and Control, e.g. Alt+Shift+a sends Meta-A (0xc1),
  1283. - *    Alt+Control+A sends Meta-Ctrl-A (0x81) ...
  1284. + *  - The Alt (= Meta) key works in combination with Shift and
  1285. + *    Control, e.g. Alt+Shift+a sends Meta-A (0xc1), Alt+Control+A sends
  1286. + *    Meta-Ctrl-A (0x81) ...
  1287.   *
  1288. - *  - The parentheses on the keypad send '(' and ')' with all modifiers (as would do e.g. keypad '+'), but they cannot
  1289. - *    be used as application keys (i.e. sending Esc O c).
  1290. + *  - The parentheses on the keypad send '(' and ')' with all
  1291. + *    modifiers (as would do e.g. keypad '+'), but they cannot be used as
  1292. + *    application keys (i.e. sending Esc O c).
  1293.   *
  1294. - *  - HELP and UNDO are mapped to be F11 and F12, resp. This way, applications that allow their own keyboard mappings
  1295. - *    (e.g. tcsh, X Windows) can be configured to use them in the way the Label suggests (providing help or undoing).
  1296. + *  - HELP and UNDO are mapped to be F21 and F24, resp, that send the
  1297. + *    codes "\E[M" and "\E[P". (This is better than the old mapping to
  1298. + *    F11 and F12, because these codes are on Shift+F1/2 anyway.) This
  1299. + *    way, applications that allow their own keyboard mappings
  1300. + *    (e.g. tcsh, X Windows) can be configured to use them in the way
  1301. + *    the label suggests (providing help or undoing).
  1302.   *
  1303. - *  - Console switching is done with Alt+Fx (consoles 1..10) and Shift+Alt+Fx (consoles 11..20).
  1304. + *  - Console switching is done with Alt+Fx (consoles 1..10) and
  1305. + *    Shift+Alt+Fx (consoles 11..20).
  1306.   *
  1307. - *  - The misc. special function implemented in the kernel are mapped to the following key combinations:
  1308. + *  - The misc. special function implemented in the kernel are mapped
  1309. + *    to the following key combinations:
  1310.   *
  1311.   *      ClrHome          -> Home/Find
  1312.   *      Shift + ClrHome  -> End/Select
  1313. @@ -61,9 +69,13 @@
  1314.   *      Alt + Insert     -> stop/start output (same as ^S/^Q)
  1315.   *      Alt + Up         -> Scroll back console (if implemented)
  1316.   *      Alt + Down       -> Scroll forward console (if implemented)
  1317. + *      Alt + CapsLock   -> NumLock
  1318.   *
  1319.   */
  1320.  
  1321. +#define K_F21    K_MACRO
  1322. +#define K_F24    K_PAUSE
  1323. +
  1324.  unsigned short atakey_map[NR_KEYMAPS][NR_KEYS] = {
  1325.      { /* no modifiers */
  1326.  /* 00-03 */    K_HOLE,    '['&0x1f,    '1',    '2',
  1327. @@ -90,7 +102,7 @@
  1328.  /* 54-57 */    K_HOLE,    K_HOLE,    K_HOLE,    K_HOLE,
  1329.  /* 58-5b */    K_HOLE,    K_HOLE,    K_HOLE,    K_HOLE,
  1330.  /* 5c-5f */    K_HOLE,    K_HOLE,    K_HOLE,    K_HOLE,
  1331. -/* 60-63 */    '<',    K_F12,    K_HELP,    '(',
  1332. +/* 60-63 */    K_HOLE,    K_F24,    K_F21,    '(',
  1333.  /* 64-67 */    ')',    K_PSLASH,    K_PSTAR,    K_P7,
  1334.  /* 68-6b */    K_P8,    K_P9,    K_P4,    K_P5,
  1335.  /* 6c-6f */    K_P6,    K_P1,    K_P2,    K_P3,
  1336. @@ -123,7 +135,7 @@
  1337.  /* 54-57 */    K_HOLE,    K_HOLE,    K_HOLE,    K_HOLE,
  1338.  /* 58-5b */    K_HOLE,    K_HOLE,    K_HOLE,    K_HOLE,
  1339.  /* 5c-5f */    K_HOLE,    K_HOLE,    K_HOLE,    K_HOLE,
  1340. -/* 60-63 */    '>',    K_BREAK,    K_SH_MEM,    '(',
  1341. +/* 60-63 */    K_HOLE,    K_BREAK,    K_SH_MEM,    '(',
  1342.  /* 64-67 */    ')',    K_PSLASH,    K_PSTAR,    K_P7,
  1343.  /* 68-6b */    K_P8,    K_P9,    K_P4,    K_P5,
  1344.  /* 6c-6f */    K_P6,    K_P1,    K_P2,    K_P3,
  1345. @@ -222,7 +234,7 @@
  1346.  /* 54-57 */    K_HOLE,    K_HOLE,    K_HOLE,    K_HOLE,
  1347.  /* 58-5b */    K_HOLE,    K_HOLE,    K_HOLE,    K_HOLE,
  1348.  /* 5c-5f */    K_HOLE,    K_HOLE,    K_HOLE,    K_HOLE,
  1349. -/* 60-63 */    '\\'&0x1f,    K_HOLE,    K_SH_REGS,    '(',
  1350. +/* 60-63 */    K_HOLE,    K_F24,    K_SH_REGS,    '(',
  1351.  /* 64-67 */    ')',    K_PSLASH,    K_PSTAR,    K_P7,
  1352.  /* 68-6b */    K_P8,    K_P9,    K_P4,    K_P5,
  1353.  /* 6c-6f */    K_P6,    K_P1,    K_P2,    K_P3,
  1354. @@ -255,7 +267,7 @@
  1355.  /* 54-57 */    K_HOLE,    K_HOLE,    K_HOLE,    K_HOLE,
  1356.  /* 58-5b */    K_HOLE,    K_HOLE,    K_HOLE,    K_HOLE,
  1357.  /* 5c-5f */    K_HOLE,    K_HOLE,    K_HOLE,    K_HOLE,
  1358. -/* 60-63 */    K_HOLE,    K_HOLE,    K_HELP,    '(',
  1359. +/* 60-63 */    K_HOLE,    K_HOLE,    K_HOLE,    '(',
  1360.  /* 64-67 */    ')',    K_PSLASH,    K_PSTAR,    K_P7,
  1361.  /* 68-6b */    K_P8,    K_P9,    K_P4,    K_P5,
  1362.  /* 6c-6f */    K_P6,    K_P1,    K_P2,    K_P3,
  1363. @@ -344,7 +356,7 @@
  1364.  /* 2c-2f */    K(KT_META,'z'),    K(KT_META,'x'),    K(KT_META,'c'),    K(KT_META,'v'),
  1365.  /* 30-33 */    K(KT_META,'b'),    K(KT_META,'n'),    K(KT_META,'m'),    K(KT_META,','),
  1366.  /* 34-37 */    K(KT_META,'.'),    K(KT_META,'/'),    K_SHIFT,    K_HOLE,
  1367. -/* 38-3b */    K_ALT,    K(KT_META,' '),    K_CAPS,    K(KT_CONS,0),
  1368. +/* 38-3b */    K_ALT,    K(KT_META,' '),    K_NUM,    K(KT_CONS,0),
  1369.  /* 3c-3f */    K(KT_CONS,1),    K(KT_CONS,2),    K(KT_CONS,3),    K(KT_CONS,4),
  1370.  /* 40-43 */    K(KT_CONS,5),    K(KT_CONS,6),    K(KT_CONS,7),    K(KT_CONS,8),
  1371.  /* 44-47 */    K(KT_CONS,9),    K_HOLE,    K_HOLE,    K_FIND,
  1372. @@ -354,7 +366,7 @@
  1373.  /* 54-57 */    K_HOLE,    K_HOLE,    K_HOLE,    K_HOLE,
  1374.  /* 58-5b */    K_HOLE,    K_HOLE,    K_HOLE,    K_HOLE,
  1375.  /* 5c-5f */    K_HOLE,    K_HOLE,    K_HOLE,    K_HOLE,
  1376. -/* 60-63 */    K(KT_META,'<'),    K_CONS,    K_SH_STAT,    '(',
  1377. +/* 60-63 */    K_HOLE,    K_CONS,    K_SH_STAT,    '(',
  1378.  /* 64-67 */    ')',    K_PSLASH,    K_PSTAR,    K_ASC7,
  1379.  /* 68-6b */    K_ASC8,    K_ASC9,    K_ASC4,    K_ASC5,
  1380.  /* 6c-6f */    K_ASC6,    K_ASC1,    K_ASC2,    K_ASC3,
  1381. @@ -387,7 +399,7 @@
  1382.  /* 54-57 */    K_HOLE,    K_HOLE,    K_HOLE,    K_HOLE,
  1383.  /* 58-5b */    K_HOLE,    K_HOLE,    K_HOLE,    K_HOLE,
  1384.  /* 5c-5f */    K_HOLE,    K_HOLE,    K_HOLE,    K_HOLE,
  1385. -/* 60-63 */    K(KT_META,'>'),    K_HOLE,    K_HELP,    '(',
  1386. +/* 60-63 */    K_HOLE,    K_HOLE,    K_HOLE,    '(',
  1387.  /* 64-67 */    ')',    K_PSLASH,    K_PSTAR,    K_P7,
  1388.  /* 68-6b */    K_P8,    K_P9,    K_P4,    K_P5,
  1389.  /* 6c-6f */    K_P6,    K_P1,    K_P2,    K_P3,
  1390. @@ -486,7 +498,7 @@
  1391.  /* 54-57 */    K_HOLE,    K_HOLE,    K_HOLE,    K_HOLE,
  1392.  /* 58-5b */    K_HOLE,    K_HOLE,    K_HOLE,    K_HOLE,
  1393.  /* 5c-5f */    K_HOLE,    K_HOLE,    K_HOLE,    K_HOLE,
  1394. -/* 60-63 */    K(KT_META,'\\'&0x1f),    K_HOLE,    K_HELP,    '(',
  1395. +/* 60-63 */    K_HOLE,    K_HOLE,    K_HOLE,    '(',
  1396.  /* 64-67 */    ')',    K_PSLASH,    K_PSTAR,    K_P7,
  1397.  /* 68-6b */    K_P8,    K_P9,    K_P4,    K_P5,
  1398.  /* 6c-6f */    K_P6,    K_P1,    K_P2,    K_P3,
  1399. @@ -519,7 +531,7 @@
  1400.  /* 54-57 */    K_HOLE,    K_HOLE,    K_HOLE,    K_HOLE,
  1401.  /* 58-5b */    K_HOLE,    K_HOLE,    K_HOLE,    K_HOLE,
  1402.  /* 5c-5f */    K_HOLE,    K_HOLE,    K_HOLE,    K_HOLE,
  1403. -/* 60-63 */    K_HOLE,    K_HOLE,    K_HELP,    '(',
  1404. +/* 60-63 */    K_HOLE,    K_HOLE,    K_HOLE,    '(',
  1405.  /* 64-67 */    ')',    K_PSLASH,    K_PSTAR,    K_P7,
  1406.  /* 68-6b */    K_P8,    K_P9,    K_P4,    K_P5,
  1407.  /* 6c-6f */    K_P6,    K_P1,    K_P2,    K_P3,
  1408. @@ -552,7 +564,7 @@
  1409.  /* 54-57 */    K_HOLE,    K_HOLE,    K_HOLE,    K_HOLE,
  1410.  /* 58-5b */    K_HOLE,    K_HOLE,    K_HOLE,    K_HOLE,
  1411.  /* 5c-5f */    K_HOLE,    K_HOLE,    K_HOLE,    K_HOLE,
  1412. -/* 60-63 */    K_HOLE,    K_HOLE,    K_HELP,    K_HOLE,
  1413. +/* 60-63 */    K_HOLE,    K_HOLE,    K_HOLE,    K_HOLE,
  1414.  /* 64-67 */    K_HOLE,    K_PSLASH,    K_PSTAR,    K_P7,
  1415.  /* 68-6b */    K_P8,    K_P9,    K_P4,    K_P5,
  1416.  /* 6c-6f */    K_P6,    K_P1,    K_P2,    K_P3,
  1417. @@ -585,7 +597,7 @@
  1418.  /* 54-57 */    K_HOLE,    K_HOLE,    K_HOLE,    K_HOLE,
  1419.  /* 58-5b */    K_HOLE,    K_HOLE,    K_HOLE,    K_HOLE,
  1420.  /* 5c-5f */    K_HOLE,    K_HOLE,    K_HOLE,    K_HOLE,
  1421. -/* 60-63 */    K_HOLE,    K_HOLE,    K_HELP,    K_HOLE,
  1422. +/* 60-63 */    K_HOLE,    K_HOLE,    K_HOLE,    K_HOLE,
  1423.  /* 64-67 */    K_HOLE,    K_PSLASH,    K_PSTAR,    K_P7,
  1424.  /* 68-6b */    K_P8,    K_P9,    K_P4,    K_P5,
  1425.  /* 6c-6f */    K_P6,    K_P1,    K_P2,    K_P3,
  1426. @@ -615,69 +627,31 @@
  1427.  #define    DEFAULT_KEYB_REP_DELAY    (HZ/4)
  1428.  #define    DEFAULT_KEYB_REP_RATE    (HZ/25)
  1429.  
  1430. +/* These could be settable by some ioctl() in future... */
  1431.  unsigned int key_repeat_delay = DEFAULT_KEYB_REP_DELAY;
  1432.  unsigned int key_repeat_rate  = DEFAULT_KEYB_REP_RATE;
  1433.  
  1434. -
  1435. -#if 0
  1436. -
  1437. -/*
  1438. - * This table maps the Atari keyboard scan codes to
  1439. - * the Linux "virtual" scan codes.  These "virtual" scan
  1440. - * codes mostly conform to the scan codes given by an IBM
  1441. - * keyboard, except that the E0 xx codes are given unique
  1442. - * codes.  These are the codes > 96.  See linux/keyboard.h
  1443. - */
  1444. -
  1445. -static unsigned char atari_kmap[] =
  1446. -{
  1447. -/* 00-03 */    KB_NONE,       KB_ESCAPE,    KB_1,      KB_2,
  1448. -/* 04-07 */    KB_3,          KB_4,        KB_5,      KB_6,
  1449. -/* 08-0B */    KB_7,          KB_8,        KB_9,      KB_0,
  1450. -/* 0C-0F */    KB_DASH,       KB_EQUAL,     KB_BACKSPACE, KB_TAB,
  1451. -/* 10-13 */    KB_Q,          KB_W,        KB_E,      KB_R,
  1452. -/* 14-17 */    KB_T,          KB_Y,        KB_U,      KB_I,
  1453. -/* 18-1B */    KB_O,          KB_P,        KB_LSQUARE,   KB_RSQUARE,
  1454. -/* 1C-1F */    KB_ENTER,      KB_LCTRL,        KB_A,      KB_S,
  1455. -/* 20-23 */    KB_D,          KB_F,        KB_G,      KB_H,
  1456. -/* 24-27 */    KB_J,          KB_K,        KB_L,      KB_SEMICOLON,
  1457. -/* 28-2B */    KB_APOSTROPHE, KB_BACKQUOTE, KB_LSHIFT,    KB_BACKSLASH,
  1458. -/* 2C-2F */    KB_Z,          KB_X,        KB_C,      KB_V,
  1459. -/* 30-33 */    KB_B,          KB_N,        KB_M,         KB_COMMA,
  1460. -/* 34-37 */    KB_PERIOD,     KB_SLASH,     KB_RSHIFT,    KB_NONE,
  1461. -/* 38-3B */    KB_LALT,       KB_SPACE,     KB_CAPS,      KB_F1,
  1462. -/* 3C-3F */    KB_F2,         KB_F3,        KB_F4,      KB_F5,
  1463. -/* 40-43 */    KB_F6,         KB_F7,        KB_F8,      KB_F9,
  1464. -/* 44-47 */    KB_F10,        KB_NONE,      KB_NONE,      KB_FIND,
  1465. -/* 48-4B */    KB_UP,         KB_NONE,        KB_KPMINUS,   KB_LEFT,
  1466. -/* 4C-4F */    KB_NONE,       KB_RIGHT,     KB_KPPLUS,    KB_NONE,
  1467. -/* 50-53 */    KB_DOWN,       KB_NONE,        KB_INSERT,      KB_DELETE,
  1468. -/* 54-57 */    KB_NONE,          KB_NONE,        KB_NONE,      KB_NONE,
  1469. -/* 58-5B */    KB_NONE,          KB_NONE,        KB_NONE,      KB_NONE,
  1470. -/* 5B-5F */    KB_NONE,       KB_NONE,      KB_NONE,      KB_NONE,
  1471. -/* 60-63 */    KB_LESS,       KB_UNDO,      KB_HELP,      KB_KPLPAR,
  1472. -/* 64-67 */    KB_KPRPAR,     KB_KPDIVIDE,  KB_KPMULTIPLY,KB_KP7,
  1473. -/* 68-6B */    KB_KP8,        KB_KP9,        KB_KP4,      KB_KP5,
  1474. -/* 6C-6F */    KB_KP6,        KB_KP1,        KB_KP2,      KB_KP3,
  1475. -/* 70-73 */    KB_KP0,        KB_KPDECIMAL, KB_KPENTER,      KB_NONE,
  1476. -/* 74-77 */    KB_NONE,       KB_NONE,        KB_NONE,      KB_NONE,
  1477. -/* 78-7B */    KB_NONE,       KB_NONE,        KB_NONE,      KB_NONE,
  1478. -/* 7C-7F */    KB_NONE,       KB_NONE,        KB_NONE,      KB_NONE
  1479. -};
  1480. -
  1481. -#endif
  1482. -
  1483. -
  1484.  static unsigned char rep_scancode;
  1485.  static struct timer_list atakeyb_rep_timer = { NULL, NULL, 0, 0, atakeyb_rep };
  1486.  
  1487.  
  1488.  static void atakeyb_rep( unsigned long ignore )
  1489.  
  1490. -{
  1491. +{    unsigned long flags;
  1492. +    
  1493. +    /* process_scancode() mucks around with the tty queues without
  1494. +     * disabling interrupts! It assumes that it is called from an irq...
  1495. +     */
  1496. +    save_flags(flags);
  1497. +    cli();
  1498. +
  1499. +    del_timer( &atakeyb_rep_timer );
  1500.      atakeyb_rep_timer.expires = key_repeat_rate;
  1501.      add_timer( &atakeyb_rep_timer );
  1502. +
  1503.      process_scancode( rep_scancode );
  1504. +
  1505. +    restore_flags(flags);
  1506.  }
  1507.  
  1508.  
  1509. @@ -687,13 +661,22 @@
  1510.    int scancode;
  1511.    int break_flag;
  1512.  
  1513. + repeat:
  1514.    acia_stat = acia.key_ctrl;
  1515.    /* check out if the interrupt came from this ACIA */
  1516.    if (!(acia_stat & ACIA_IRQ))
  1517.      return;
  1518.  
  1519. +    if (acia_stat & ACIA_OVRN)
  1520. +    {
  1521. +    /* a very fast typist or a slow system, give a warning */
  1522. +    printk( "Keyboard overrun\n" );
  1523. +    goto get_key;
  1524. +    }
  1525. +
  1526.      if (acia_stat & ACIA_RDRF)    /* received a character */
  1527.      {
  1528. +    get_key:
  1529.      scancode = acia.key_data;    /* get it or reset the ACIA, I'll get it! */
  1530.      switch (kb_state.state)
  1531.      {
  1532. @@ -809,13 +792,13 @@
  1533.  
  1534.      if (acia_stat & (ACIA_FE | ACIA_PE))
  1535.      {
  1536. -    panic("Error in keyboard communication");
  1537. +    printk("Error in keyboard communication");
  1538.      }
  1539.  
  1540. -    if (acia_stat & ACIA_OVRN)
  1541. -    {
  1542. -    /* a very fast typist or a slow system, give a warning */    
  1543. -    }
  1544. +    /* process_scancode() can take a lot of time, so check again if
  1545. +     * some character arrived
  1546. +     */
  1547. +    goto repeat;
  1548.  }
  1549.  
  1550.  #ifdef KEYB_WRITE_INTERRUPT
  1551. @@ -1098,6 +1081,7 @@
  1552.      kb_state.len = 0;
  1553.  
  1554.      /* enable ACIA Interrupts */ 
  1555. +    mfp.active_edge &= ~0x10;
  1556.      mfp.int_en_b |= 0x40;
  1557.  
  1558.    return kmem_start;
  1559. diff -ubr -x RCS -x *.[ao] -x .depend -x .version -x .config -x System.map -x vmlinux -x bootstrap -x *~ -x config.old -x *.orig -x *.rej -x *# -x version.h -x autoconf.h --new-file linux-0.9pl3/atari/config.c linux-0.9pl4/atari/config.c
  1560. --- linux-0.9pl3/atari/config.c    Sun Aug 14 10:30:00 1994
  1561. +++ linux-0.9pl4/atari/config.c    Mon Nov 21 18:08:55 1994
  1562. @@ -33,6 +33,7 @@
  1563.  #include <linux/atariints.h>
  1564.  
  1565.  #include <asm/system.h>
  1566. +#include <asm/io.h>
  1567.  
  1568.  
  1569.  /* ++andreas: timer interrupt fixed to have perfect 100 Hz */
  1570. @@ -93,14 +94,14 @@
  1571.  
  1572.  #define    RTC_READ(reg)                            \
  1573.      ({    unsigned char    __val;                    \
  1574. -        tt_rtc.regsel = (reg);                    \
  1575. +        outb(reg,&tt_rtc.regsel);                \
  1576.          __val = tt_rtc.data;                    \
  1577.          __val;                                    \
  1578.      })
  1579.  
  1580.  #define    RTC_WRITE(reg,val)                        \
  1581.      do {                                        \
  1582. -        tt_rtc.regsel = (reg);                    \
  1583. +        outb(reg,&tt_rtc.regsel);                \
  1584.          tt_rtc.data = (val);                    \
  1585.      } while(0)
  1586.      
  1587. @@ -108,15 +109,11 @@
  1588.  void atari_gettod( struct mktime *time )
  1589.  
  1590.  {
  1591. -        int                i;
  1592.          unsigned char    ctrl;
  1593. +        unsigned short     tos_version;
  1594.          
  1595. -        for (i = 0 ; i < 1000000 ; i++)    /* may take up to 1 second... */
  1596. -            if (RTC_READ(RTC_FREQ_SELECT) & RTC_UIP)
  1597. -                break;
  1598. -        for (i = 0 ; i < 1000000 ; i++)    /* must try at least 2.228 ms*/
  1599. -            if (!(RTC_READ(RTC_FREQ_SELECT) & RTC_UIP))
  1600. -                break;
  1601. +        while (!(RTC_READ(RTC_FREQ_SELECT) & RTC_UIP)) ;
  1602. +        while (RTC_READ(RTC_FREQ_SELECT) & RTC_UIP) ;
  1603.  
  1604.          time->sec  = RTC_READ(RTC_SECONDS);
  1605.          time->min  = RTC_READ(RTC_MINUTES);
  1606. @@ -125,10 +122,6 @@
  1607.          time->mon  = RTC_READ(RTC_MONTH);
  1608.          time->year = RTC_READ(RTC_YEAR);
  1609.  
  1610. -        /* Adjust values (let the setup valid for TOS) */
  1611. -        time->mon--;
  1612. -        time->year += 68;
  1613. -
  1614.          ctrl = RTC_READ(RTC_CONTROL); 
  1615.  
  1616.          if (!(ctrl & RTC_DM_BINARY)) {
  1617. @@ -145,6 +138,11 @@
  1618.                  time->hour += 12;
  1619.              }
  1620.          }
  1621. +    /* Adjust values (let the setup valid) */
  1622. +    time->mon--;
  1623. +    /* Tos version at Physical 2 */
  1624. +    tos_version = *(unsigned short *)PTOV( 2 );
  1625. +    time->year += (tos_version < 0x306) ? 70 : 68;
  1626.  }
  1627.  
  1628.  
  1629. diff -ubr -x RCS -x *.[ao] -x .depend -x .version -x .config -x System.map -x vmlinux -x bootstrap -x *~ -x config.old -x *.orig -x *.rej -x *# -x version.h -x autoconf.h --new-file linux-0.9pl3/atari/joystick.c linux-0.9pl4/atari/joystick.c
  1630. --- linux-0.9pl3/atari/joystick.c    Sun Aug 14 10:30:33 1994
  1631. +++ linux-0.9pl4/atari/joystick.c    Mon Nov 21 18:08:55 1994
  1632. @@ -1,15 +1,21 @@
  1633.  /*
  1634.   * Atari Joystick Driver for Linux
  1635.   * by Robert de Vries (robert@and.nl) 19Jul93
  1636. + *
  1637. + * 16 Nov 1994 Andreas Schwab
  1638. + * Support for three button mouse (shamelessly stolen from MiNT)
  1639. + * third button wired to one of the joystick directions on joystick 1
  1640.   */
  1641.  
  1642.  #include <linux/sched.h>
  1643.  #include <linux/errno.h>
  1644.  #include <linux/atarikb.h>
  1645.  #include <linux/atari_joystick.h>
  1646. +#include <linux/atari_mouse.h>
  1647.  #include <asm/segment.h>
  1648.  
  1649.  static struct joystick_status joystick[2];
  1650. +extern int atari_mouse_buttons; /* for three-button mouse */
  1651.  
  1652.  void joystick_interrupt(char *buf)
  1653.  {
  1654. @@ -21,6 +27,18 @@
  1655.      joystick[j].fire  = (buf[1] & 0x80) >> 7;
  1656.      joystick[j].ready = 1;
  1657.      wake_up_interruptible(&joystick[j].wait);
  1658. +
  1659. +    /* For three-button mouse emulation fake a mouse packet */
  1660. +    if (j == 1 && (buf[1] & 1) != ((atari_mouse_buttons & 2) >> 1))
  1661. +      {
  1662. +    char faked_packet[3];
  1663. +
  1664. +    atari_mouse_buttons = (atari_mouse_buttons & 5) | ((buf[1] & 1) << 1);
  1665. +    faked_packet[0] = atari_mouse_buttons;
  1666. +    faked_packet[1] = 0;
  1667. +    faked_packet[2] = 0;
  1668. +    atari_mouse_interrupt (faked_packet);
  1669. +      }
  1670.  
  1671.  /*    ikbd_joystick_event_on(); */
  1672.  }
  1673. diff -ubr -x RCS -x *.[ao] -x .depend -x .version -x .config -x System.map -x vmlinux -x bootstrap -x *~ -x config.old -x *.orig -x *.rej -x *# -x version.h -x autoconf.h --new-file linux-0.9pl3/atari/stdma.c linux-0.9pl4/atari/stdma.c
  1674. --- linux-0.9pl3/atari/stdma.c    Tue Sep 27 22:21:22 1994
  1675. +++ linux-0.9pl4/atari/stdma.c    Tue Nov  8 18:31:59 1994
  1676. @@ -14,20 +14,31 @@
  1677.  /* This file contains some function for controlling the access to the  */
  1678.  /* ST-DMA chip that may be shared between devices. Currently we have:  */
  1679.  /*   TT:     Floppy and ACSI bus                                       */
  1680. -/*   Falcon: Floppy, SCSI and IDE                                      */
  1681. +/*   Falcon: Floppy and SCSI                                           */
  1682.  /*                                                                     */
  1683.  /* The controlling functions set up a wait queue for access to the     */
  1684.  /* ST-DMA chip. Callers to stdma_lock() that cannot granted access are */
  1685.  /* put onto a queue and waked up later if the owner calls              */
  1686.  /* stdma_release(). Additionally, the caller gives his interrupt       */
  1687.  /* service routine to stdma_lock().                                    */
  1688. +/*                                                                     */
  1689. +/* On the Falcon, the IDE bus uses just the ACSI/Floppy interrupt, but */
  1690. +/* not the ST-DMA chip itself. So falhd.c needs not to lock the        */
  1691. +/* chip. The interrupt is routed to falhd.c if IDE is configured, the  */
  1692. +/* model is a Falcon and the interrupt was caused by the HD controller */
  1693. +/* (can be determined by looking at its status register).              */
  1694. +
  1695.  
  1696. +#include <linux/config.h>
  1697.  #include <linux/types.h>
  1698. +#include <linux/genhd.h>
  1699.  #include <linux/sched.h>
  1700. +#include <linux/bootinfo.h>
  1701.  #include <linux/atari_stdma.h>
  1702.  #include <linux/atariints.h>
  1703.  #include <linux/atarihw.h>
  1704. -
  1705. +#include <linux/atarihdreg.h>
  1706. +#include <asm/io.h>
  1707.  
  1708.  static int        stdma_locked = 0;                /* the semaphore */
  1709.  static isrfunc    stdma_isr = NULL;                /* int func to be called */
  1710. @@ -40,6 +51,9 @@
  1711.  /***************************** Prototypes *****************************/
  1712.  
  1713.  static void stdma_int( struct intframe *fp, void *data );
  1714. +#ifdef CONFIG_ATARI_FALCON_IDE
  1715. +extern void hd_interrupt( struct intframe *fp, void *data );
  1716. +#endif
  1717.  
  1718.  /************************* End of Prototypes **************************/
  1719.  
  1720. @@ -125,6 +139,27 @@
  1721.  
  1722.  
  1723.  /*
  1724. + * Function: int stdma_islocked( void )
  1725. + *
  1726. + * Purpose: Check if the ST-DMA is currently locked.
  1727. + * Note: This function should be called only with interrupts disbabled
  1728. + *         to avoid race conditions. Also, the returned status is only
  1729. + *         valid as long as the ints remain disabled.
  1730. + *
  1731. + * Inputs: none
  1732. + *
  1733. + * Returns: != 0 if locked, 0 otherwise
  1734. + *
  1735. + */
  1736. +
  1737. +int stdma_islocked( void )
  1738. +
  1739. +{
  1740. +    return( stdma_locked );
  1741. +}
  1742. +
  1743. +
  1744. +/*
  1745.   * Function: void stdma_init( void )
  1746.   *
  1747.   * Purpose: Initialize the ST-DMA chip access controlling.
  1748. @@ -157,6 +192,12 @@
  1749.  static void stdma_int( struct intframe *fp, void *data )
  1750.  
  1751.  {
  1752. +#ifdef CONFIG_ATARI_FALCON_IDE
  1753. +  if (boot_info.bi_atari.model == ATARI_FALCON &&
  1754. +      (inb (HD_IRQ_TEST) & 0xad))
  1755. +      hd_interrupt( fp, data );
  1756. +  else
  1757. +#endif
  1758.      if (stdma_isr)
  1759.          (*stdma_isr)( fp, stdma_isr_data );
  1760.  }
  1761. diff -ubr -x RCS -x *.[ao] -x .depend -x .version -x .config -x System.map -x vmlinux -x bootstrap -x *~ -x config.old -x *.orig -x *.rej -x *# -x version.h -x autoconf.h --new-file linux-0.9pl3/atari/stram.c linux-0.9pl4/atari/stram.c
  1762. --- linux-0.9pl3/atari/stram.c    Sun Aug 14 10:30:34 1994
  1763. +++ linux-0.9pl4/atari/stram.c    Mon Nov  7 22:10:07 1994
  1764. @@ -1,8 +1,11 @@
  1765. +
  1766.  #include <linux/types.h>
  1767.  #include <linux/kernel.h>
  1768.  #include <linux/bootinfo.h>
  1769.  #include <linux/atarihw.h>
  1770.  
  1771. +#if 0
  1772. +
  1773.  struct stram_desc
  1774.    {
  1775.      unsigned first:1;
  1776. @@ -139,3 +142,99 @@
  1777.        edp = dp2;
  1778.      }
  1779.  }
  1780. +
  1781. +#else
  1782. +
  1783. +#include <linux/mm.h>
  1784. +
  1785. +/* ++roman:
  1786. + * 
  1787. + * New version of ST-Ram buffer allocation. Instead of using the
  1788. + * 1 MB - 4 KB that remain when the the ST-Ram chunk starts at $1000
  1789. + * (1 MB granularity!), such buffers are reserved like this:
  1790. + *
  1791. + *  - If the kernel resides in ST-Ram anyway, we can take the buffer
  1792. + *    from behind the current kernel data space the normal way
  1793. + *    (incrementing start_mem).
  1794. + *    
  1795. + *  - If the kernel is in TT-Ram, stram_init() initializes start and
  1796. + *    end of the available region. Buffers are allocated from there
  1797. + *    and mem_init() later marks the such used pages as reserved.
  1798. + *    Since each TT-Ram chunk is at least 4 MB in size, I hope there
  1799. + *    won't be an overrun of the ST-Ram region by normal kernel data
  1800. + *    space.
  1801. + *    
  1802. + * For that, ST-Ram may only be allocated while kernel initialization
  1803. + * is going on, or exactly: before mem_init() is called. There is also
  1804. + * no provision now for freeing ST-Ram buffers. It seems that isn't
  1805. + * really needed.
  1806. + *
  1807. + * ToDo:
  1808. + * Check the high level scsi code what is done when the
  1809. + * UNCHECKED_ISA_DMA flag is set. It guess, it is just a test for adr
  1810. + * < 16 Mega. There should be call to atari_stram_alloc() instead.
  1811. + *
  1812. + * Also ToDo:
  1813. + * Go through head.S and delete parts no longer needed (transparent
  1814. + * mapping of ST-Ram etc.)
  1815. + * 
  1816. + */
  1817. +   
  1818. +
  1819. +unsigned long rsvd_stram_beg, rsvd_stram_end;
  1820. +    /* Start and end of the reserved ST-Ram region */
  1821. +static unsigned long stram_end;
  1822. +    /* Overall end of ST-Ram */
  1823. +
  1824. +
  1825. +void atari_stram_init( void )
  1826. +
  1827. +{    int        i;
  1828. +
  1829. +    for( i = 0; i < boot_info.num_memory; ++i ) {
  1830. +        if (boot_info.memory[i].addr == 0) {
  1831. +            rsvd_stram_beg = PTOV( 0x800 ); /* skip super-only first 2 KB! */
  1832. +            rsvd_stram_end = rsvd_stram_beg;
  1833. +            stram_end = rsvd_stram_beg - 0x800 + boot_info.memory[i].size;
  1834. +            return;
  1835. +        }
  1836. +    }
  1837. +    /* Should never come here! (There is always ST-Ram!) */
  1838. +}
  1839. +
  1840. +
  1841. +void *atari_stram_alloc( long size, unsigned long *start_mem )
  1842. +
  1843. +{
  1844. +    static int                kernel_in_stram = -1;
  1845. +    
  1846. +    void    *adr = 0;
  1847. +    
  1848. +    if (kernel_in_stram < 0)
  1849. +        kernel_in_stram = (PTOV( 0 ) == KSTART_ADDR);
  1850. +
  1851. +    if (kernel_in_stram) {
  1852. +        /* Get memory from kernel data space */
  1853. +        adr = (void *) *start_mem;
  1854. +        *start_mem += size;
  1855. +    }
  1856. +    else {
  1857. +        /* Get memory from rsvd_stram_beg */
  1858. +        if (rsvd_stram_end + size < stram_end) {
  1859. +            adr = (void *) rsvd_stram_end;
  1860. +            rsvd_stram_end += size;
  1861. +        }
  1862. +    }
  1863. +    
  1864. +    return( adr );
  1865. +}
  1866. +
  1867. +void atari_stram_free( void *ptr )
  1868. +
  1869. +{
  1870. +    /* Sorry, this is a dummy. It isn't needed anyway. */
  1871. +}
  1872. +
  1873. +#endif
  1874. +
  1875. +
  1876. diff -ubr -x RCS -x *.[ao] -x .depend -x .version -x .config -x System.map -x vmlinux -x bootstrap -x *~ -x config.old -x *.orig -x *.rej -x *# -x version.h -x autoconf.h --new-file linux-0.9pl3/config.in linux-0.9pl4/config.in
  1877. --- linux-0.9pl3/config.in    Thu Sep 29 18:27:15 1994
  1878. +++ linux-0.9pl4/config.in    Fri Nov 11 21:01:08 1994
  1879. @@ -19,6 +19,7 @@
  1880.  if [ "$CONFIG_ATARI" = "y" ]
  1881.  bool 'Atari Falcon IDE harddisk support' CONFIG_ATARI_FALCON_IDE y
  1882.  bool 'Limit Floppy drive to DD only' CONFIG_FLOPPY_DD_ONLY n
  1883. +bool 'Atari ACSI support' CONFIG_ATARI_ACSI y
  1884.  fi
  1885.  bool 'TCP/IP networking' CONFIG_INET y
  1886.  bool 'Limit memory to low 16MB' CONFIG_MAX_16M n
  1887. @@ -106,7 +107,7 @@
  1888.  bool 'xiafs filesystem support' CONFIG_XIA_FS n
  1889.  bool 'msdos fs support' CONFIG_MSDOS_FS y
  1890.  bool '/proc filesystem support' CONFIG_PROC_FS y
  1891. -bool 'NFS filesystem support' CONFIG_NFS_FS n
  1892. +bool 'NFS filesystem support' CONFIG_NFS_FS y
  1893.  bool 'ISO9660 cdrom filesystem support' CONFIG_ISO9660_FS y
  1894.  bool 'System V and Coherent filesystem support' CONFIG_SYSV_FS n
  1895.  bool 'Amiga FFS filesystem support' CONFIG_AFFS_FS y
  1896. @@ -120,7 +121,7 @@
  1897.  if [ "$CONFIG_ATARI" = "y" ]
  1898.  bool 'Atari mouse support' CONFIG_ATARIMOUSE y
  1899.  fi
  1900. -bool 'Selection (cut and paste for virtual consoles)' CONFIG_SELECTION n
  1901. +bool 'Selection (cut and paste for virtual consoles)' CONFIG_SELECTION y
  1902.  bool 'QIC-02 tape support' CONFIG_TAPE_QIC02 n
  1903.  bool 'QIC-117 tape support' CONFIG_FTAPE n
  1904.  if [ "$CONFIG_FTAPE" = "y" ]
  1905. diff -ubr -x RCS -x *.[ao] -x .depend -x .version -x .config -x System.map -x vmlinux -x bootstrap -x *~ -x config.old -x *.orig -x *.rej -x *# -x version.h -x autoconf.h --new-file linux-0.9pl3/drivers/block/Makefile linux-0.9pl4/drivers/block/Makefile
  1906. --- linux-0.9pl3/drivers/block/Makefile    Sun Aug 14 10:30:43 1994
  1907. +++ linux-0.9pl4/drivers/block/Makefile    Mon Nov  7 22:11:26 1994
  1908. @@ -57,6 +57,11 @@
  1909.  SRCS := $(SRCS) xd.c
  1910.  endif
  1911.  
  1912. +ifdef CONFIG_ATARI_ACSI
  1913. +OBJS := $(OBJS) acsi.o
  1914. +SRCS := $(SRCS) acsi.c
  1915. +endif
  1916. +
  1917.  all: block.a
  1918.  
  1919.  block.a: $(OBJS)
  1920. diff -ubr -x RCS -x *.[ao] -x .depend -x .version -x .config -x System.map -x vmlinux -x bootstrap -x *~ -x config.old -x *.orig -x *.rej -x *# -x version.h -x autoconf.h --new-file linux-0.9pl3/drivers/block/acsi.c linux-0.9pl4/drivers/block/acsi.c
  1921. --- linux-0.9pl3/drivers/block/acsi.c    Wed Dec 31 19:00:00 1969
  1922. +++ linux-0.9pl4/drivers/block/acsi.c    Thu Nov 24 21:37:38 1994
  1923. @@ -0,0 +1,1442 @@
  1924. +/*
  1925. + * acsi.c -- Device driver for Atari ACSI hard disks
  1926. + *
  1927. + * Copyright 1994 Roman Hodek
  1928. + *   EMail: rnhodek@cip.informatik.uni-erlangen.de (Internet)
  1929. + *      or: Roman_Hodek@n.maus.de (MausNet, NO mail > 16 KB!)
  1930. + *
  1931. + * Some parts are based on hd.c by Linus Thorvalds
  1932. + *
  1933. + * This file is subject to the terms and conditions of the GNU General Public
  1934. + * License.  See the file README.legal in the main directory of this archive
  1935. + * for more details.
  1936. + *
  1937. + */
  1938. +
  1939. +/*
  1940. + * Still to in this file:
  1941. + *  - There is also the "bits get set somewhere while DMA" problem as
  1942. + *    with the floppy driver. See there. Maybe this is a hardware problem.
  1943. + *  - If a command ends with an error status (!= 0), the following
  1944. + *    REQUEST SENSE commands (4 to fill the ST-DMA FIFO) are done by
  1945. + *    polling the _IRQ signal (not interrupt-driven). This should be
  1946. + *    avoided in future because it takes up a non-neglectible time in
  1947. + *    the interrupt service routine while interrupts are disabled.
  1948. + *    Maybe a timer interrupt will get lost :-(
  1949. + */
  1950. +
  1951. +/*
  1952. + * General notes:
  1953. + *
  1954. + *  - All ACSI devices (disks, CD-ROMs, ...) use major number 28.
  1955. + *    Minors are organized like it is with SCSI: The upper 4 bits
  1956. + *    identify the device, the lower 4 bits the partition.
  1957. + *    The device numbers (the upper 4 bits) are given in the same
  1958. + *    order as the devices are found on the bus.
  1959. + *  - Up to 8 LUNs are supported for each target, but only a total of
  1960. + *    16 devices (due to minor numbers...). Note that Atari allows
  1961. + *    only a maximum of 4 targets (i.e. controllers, not devices) on
  1962. + *    the ACSI bus!
  1963. + *  - The SLM laser printer is not supported. In many ways, it behaves
  1964. + *    different than other ACSI devices and there are other problems,
  1965. + *    too (DMA size is not a multiple of 512, intervention necessary
  1966. + *    while DMA-ing the page data).
  1967. + *  - A optimizing scheme similar to SCSI scatter-gather is implemented.
  1968. + *  - Removable media are supported. After a medium change to device
  1969. + *    is reinitialized (partition check etc.). Also, if the device
  1970. + *    knows the PREVENT/ALLOW MEDIUM REMOVAL command, the door should
  1971. + *    be locked and unlocked when mounting the first or unmounting the
  1972. + *    last filesystem on the device. The code is untested, because I
  1973. + *    don't have a removable harddisk.
  1974. + *
  1975. + */
  1976. +
  1977. + 
  1978. +#include <linux/errno.h>
  1979. +#include <linux/signal.h>
  1980. +#include <linux/sched.h>
  1981. +#include <linux/timer.h>
  1982. +#include <linux/fs.h>
  1983. +#include <linux/kernel.h>
  1984. +#include <linux/genhd.h>
  1985. +#include <linux/delay.h>
  1986. +
  1987. +#include <linux/bootinfo.h>
  1988. +#include <linux/interrupt.h>
  1989. +#include <linux/atarihw.h>
  1990. +#include <linux/atari_stdma.h>
  1991. +#include <linux/atari_rootsec.h>
  1992. +
  1993. +#include <asm/system.h>
  1994. +#include <asm/segment.h>
  1995. +
  1996. +#if 0
  1997. +extern unsigned long RCont;
  1998. +
  1999. +#define TEST_PAGE(str,adr)                                    \
  2000. +    do {                                                    \
  2001. +        unsigned long flags;                                \
  2002. +        save_flags(flags);; cli();                            \
  2003. +        if (*(unsigned long *)0xc03ff000 != RCont) {        \
  2004. +            printk("*0xc03ff000 = %08lx mem_map[]=%d\n",    \
  2005. +                   (RCont = *(unsigned long *)0xc03ff000),    \
  2006. +                   mem_map[MAP_NR(0xc03ff000)] );            \
  2007. +            printk("%s ",(str));                            \
  2008. +            printk("%08lx\n",(unsigned long)(adr));            \
  2009. +        }                                                    \
  2010. +        restore_flags(flags);                                \
  2011. +    } while(0)
  2012. +
  2013. +#else
  2014. +
  2015. +#define TEST_PAGE(str,adr) do {} while(0)
  2016. +
  2017. +#endif
  2018. +
  2019. +
  2020. +#define MAJOR_NR ACSI_MAJOR
  2021. +#include "blk.h"
  2022. +
  2023. +#define DEBUG
  2024. +#undef NO_WRITE
  2025. +
  2026. +#define MAX_ERRORS             8    /* Max read/write errors/sector */
  2027. +#define MAX_LUN                8    /* Max LUNs per target */
  2028. +#define MAX_DEV                   16
  2029. +
  2030. +#define ACSI_BUFFER_SIZE    (16*1024)
  2031. +#define ACSI_BUFFER_SECTORS    (ACSI_BUFFER_SIZE/512)
  2032. +
  2033. +#define ACSI_TIMEOUT        (4*HZ)
  2034. +
  2035. +
  2036. +typedef enum {
  2037. +    NONE, HARDDISK, CDROM
  2038. +} ACSI_TYPE;
  2039. +
  2040. +struct acsi_info_struct {
  2041. +    ACSI_TYPE        type;            /* type of device */
  2042. +    unsigned        target;            /* target number */
  2043. +    unsigned        lun;            /* LUN in target controller */
  2044. +    unsigned        removable : 1;    /* Flag for removable media */
  2045. +    unsigned        read_only : 1;    /* Flag for read only devices */
  2046. +    unsigned        changed : 1;    /* Medium has been changed */
  2047. +    unsigned long     size;            /* #blocks */
  2048. +} acsi_info[MAX_DEV];
  2049. +
  2050. +typedef struct {
  2051. +    unsigned long    dummy[2];
  2052. +    unsigned long    sector_size;
  2053. +    unsigned char    format_code;
  2054. +#define SENSE_FORMAT_FIX    1    
  2055. +#define SENSE_FORMAT_CHNG    2
  2056. +    unsigned char    cylinders_h;
  2057. +    unsigned char    cylinders_l;
  2058. +    unsigned char    heads;
  2059. +    unsigned char    reduced_h;
  2060. +    unsigned char    reduced_l;
  2061. +    unsigned char    precomp_h;
  2062. +    unsigned char    precomp_l;
  2063. +    unsigned char    landing_zone;
  2064. +    unsigned char    steprate;
  2065. +    unsigned char    type;
  2066. +#define SENSE_TYPE_FIXCHNG_MASK        4
  2067. +#define SENSE_TYPE_SOFTHARD_MASK    8
  2068. +#define SENSE_TYPE_FIX                4
  2069. +#define SENSE_TYPE_CHNG                0
  2070. +#define SENSE_TYPE_SOFT                0
  2071. +#define SENSE_TYPE_HARD                8
  2072. +    unsigned char    sectors;
  2073. +} SENSE_DATA;
  2074. +
  2075. +#define CAPACITY(sd)    (((int)((sd).cylinders_h<<8)|(sd).cylinders_l) * \
  2076. +                         (sd).heads * \
  2077. +                         (sd).sectors)
  2078. +
  2079. +static char             *acsi_buffer;
  2080. +static unsigned long     phys_acsi_buffer;
  2081. +static int                NDevices = 0;
  2082. +static int                acsi_sizes[MAX_DEV<<4] = { 0, };
  2083. +static int                acsi_blocksizes[MAX_DEV<<4] = { 0, };
  2084. +static struct hd_struct    acsi_part[MAX_DEV<<4] = { {0,0}, };
  2085. +static int                 access_count[MAX_DEV] = { 0, };
  2086. +static char             busy[MAX_DEV] = { 0, };
  2087. +static struct wait_queue *busy_wait;
  2088. +
  2089. +static int                CurrentNReq;
  2090. +static int                CurrentNSect;
  2091. +static char                *CurrentBuffer;
  2092. +
  2093. +
  2094. +#define ENABLE_IRQ()                            \
  2095. +    do {                                        \
  2096. +        mfp.int_pn_b = 0x7f;                    \
  2097. +        mfp.int_en_b |= 0x80;                    \
  2098. +    } while(0)
  2099. +
  2100. +#define DISABLE_IRQ()                            \
  2101. +    do {                                        \
  2102. +        mfp.int_en_b &= ~0x80;                    \
  2103. +    } while(0)
  2104. +
  2105. +#define SET_TIMER()                                \
  2106. +    do {                                        \
  2107. +        del_timer( &acsi_timer );                \
  2108. +        acsi_timer.expires = ACSI_TIMEOUT;        \
  2109. +        add_timer( &acsi_timer );                \
  2110. +    } while(0)
  2111. +
  2112. +#define CLEAR_TIMER()                            \
  2113. +    do {                                        \
  2114. +        del_timer( &acsi_timer );                \
  2115. +    } while(0)
  2116. +
  2117. +#define STRAM_ADDR(a)    (((a) & 0xff000000) == 0)
  2118. +
  2119. +
  2120. +
  2121. +/* ACSI commands */
  2122. +
  2123. +static char tur_cmd[6]        = { 0x00, 0, 0, 0, 0, 0 };
  2124. +static char modesense_cmd[6]  = { 0x1a, 0, 0, 0, 24, 0 };
  2125. +static char inquiry_cmd[6]    = { 0x12, 0, 0, 0, 16, 0 };
  2126. +static char reqsense_cmd[6]   = { 0x03, 0, 0, 0, 4, 0 };
  2127. +static char read_cmd[6]       = { 0x08, 0, 0, 0, 0, 0 };
  2128. +static char write_cmd[6]      = { 0x0a, 0, 0, 0, 0, 0 };
  2129. +static char pa_med_rem_cmd[6] = { 0x1e, 0, 0, 0, 0, 0 };
  2130. +
  2131. +#define CMDSET_TARG_LUN(cmd,targ,lun)            \
  2132. +    do {                                        \
  2133. +        cmd[0] = (cmd[0] & ~0xe0) | (targ)<<5;    \
  2134. +        cmd[1] = (cmd[1] & ~0xe0) | (lun)<<5;    \
  2135. +    } while(0)
  2136. +
  2137. +#define CMDSET_BLOCK(cmd,blk)                        \
  2138. +    do {                                            \
  2139. +        unsigned long __blk = (blk);                \
  2140. +        cmd[3] = __blk; __blk >>= 8;                \
  2141. +        cmd[2] = __blk; __blk >>= 8;                \
  2142. +        cmd[1] = (cmd[1] & 0xe0) | (__blk & 0x1f);    \
  2143. +    } while(0)
  2144. +
  2145. +#define CMDSET_LEN(cmd,len)                        \
  2146. +    do {                                        \
  2147. +        cmd[4] = (len);                            \
  2148. +    } while(0)
  2149. +
  2150. +#define min(a,b)    (((a)<(b))?(a):(b))
  2151. +
  2152. +
  2153. +/* ACSI errors (from REQUEST SENSE) */
  2154. +
  2155. +struct acsi_error {
  2156. +    unsigned char    code;
  2157. +    const char        *text;
  2158. +} acsi_errors[] = {
  2159. +    { 0x00, "No error (??)" },
  2160. +    { 0x01, "No index pulses" },
  2161. +    { 0x02, "Seek not complete" },
  2162. +    { 0x03, "Write fault" },
  2163. +    { 0x04, "Drive not ready" },
  2164. +    { 0x06, "No Track 00 signal" },
  2165. +    { 0x10, "ECC error in ID field" },
  2166. +    { 0x11, "Uncorrectable data error" },
  2167. +    { 0x12, "ID field address mark not found" },
  2168. +    { 0x13, "Data field address mark not found" },
  2169. +    { 0x14, "Record not found" },
  2170. +    { 0x15, "Seek error" },
  2171. +    { 0x18, "Data check in no retry mode" },
  2172. +    { 0x19, "ECC error during verify" },
  2173. +    { 0x1a, "Access to bad block" },
  2174. +    { 0x1c, "Unformatted or bad format" },
  2175. +    { 0x20, "Invalid command" },
  2176. +    { 0x21, "Invalid block address" },
  2177. +    { 0x23, "Volume overflow" },
  2178. +    { 0x24, "Invalid argument" },
  2179. +    { 0x25, "Invalid drive number" },
  2180. +    { 0x26, "Byte zero parity check" },
  2181. +    { 0x28, "Cartride changed" },
  2182. +    { 0x2c, "Error count overflow" },
  2183. +    { 0x30, "Controller selftest failed" }
  2184. +};
  2185. +
  2186. +
  2187. +/***************************** Prototypes *****************************/
  2188. +
  2189. +static int wait_for_IRQ( unsigned timeout );
  2190. +static int wait_for_noIRQ( unsigned timeout );
  2191. +static int acsicmd_dma( const char *cmd, char *buffer, int blocks, int
  2192. +                        rwflag );
  2193. +static int acsicmd_nodma( const char *cmd );
  2194. +static int acsi_reqsense( char *buffer );
  2195. +static int acsi_getstatus( void );
  2196. +static void acsi_print_error( const unsigned char *errblk );
  2197. +static void acsi_interrupt( struct intframe *fp, void *data );
  2198. +static void unexpected_acsi_interrupt( void );
  2199. +static void bad_rw_intr( void );
  2200. +static void read_intr( void );
  2201. +static void write_intr( void);
  2202. +static void acsi_times_out( unsigned long dummy );
  2203. +static void copy_to_acsibuffer( void );
  2204. +static void copy_from_acsibuffer( void );
  2205. +static void do_end_requests( void );
  2206. +static void do_acsi_request( void );
  2207. +static void redo_acsi_request( void );
  2208. +static int acsi_ioctl( struct inode *inode, struct file *file, unsigned int
  2209. +                       cmd, unsigned long arg );
  2210. +static int acsi_open( struct inode * inode, struct file * filp );
  2211. +static void acsi_release( struct inode * inode, struct file * file );
  2212. +static void acsi_prevent_removal( int target, int flag );
  2213. +static int acsi_mode_sense( int target, int lun, SENSE_DATA *sd );
  2214. +static void acsi_geninit( void );
  2215. +int revalidate_acsidisk( int dev, int maxusage );
  2216. +
  2217. +/************************* End of Prototypes **************************/
  2218. +
  2219. +
  2220. +struct timer_list acsi_timer = { NULL, NULL, 0, 0, acsi_times_out };
  2221. +
  2222. +
  2223. +
  2224. +/***********************************************************************
  2225. + *
  2226. + *   ACSI primitives
  2227. + *
  2228. + **********************************************************************/
  2229. +
  2230. +
  2231. +/*
  2232. + * The following two functions wait for _IRQ to become Low or High,
  2233. + * resp., with a timeout. The 'timeout' parameter is in jiffies
  2234. + * (10ms).
  2235. + * If the functions are called with timer interrupts on (int level <
  2236. + * 6), the timeout is based on the 'jiffies' variable to provide exact
  2237. + * timeouts for device probing etc.
  2238. + * If interrupts are disabled, the number of tries is based on the
  2239. + * 'loops_per_sec' variable. A rough estimation is sufficient here...
  2240. + */
  2241. +
  2242. +#define INT_LEVEL                                                    \
  2243. +    ({    unsigned __sr;                                                \
  2244. +        __asm__ __volatile__ ( "movew    sr,%0" : "=dm" (__sr) );    \
  2245. +        (__sr >> 8) & 7;                                            \
  2246. +    })
  2247. +
  2248. +static int wait_for_IRQ( unsigned timeout )
  2249. +
  2250. +{
  2251. +    if (INT_LEVEL < 6) {
  2252. +        unsigned long maxjif;
  2253. +        for( maxjif = jiffies + timeout; jiffies < maxjif; )
  2254. +            if (!(mfp.par_dt_reg & 0x20)) return( 1 );
  2255. +    }
  2256. +    else {
  2257. +        long tries = loops_per_sec / HZ / 8 * timeout;
  2258. +        while( --tries >= 0 )
  2259. +            if (!(mfp.par_dt_reg & 0x20)) return( 1 );
  2260. +    }        
  2261. +    return( 0 ); /* timeout! */
  2262. +}
  2263. +
  2264. +
  2265. +static int wait_for_noIRQ( unsigned timeout )
  2266. +
  2267. +{
  2268. +    if (INT_LEVEL < 6) {
  2269. +        unsigned long maxjif;
  2270. +        for( maxjif = jiffies + timeout; jiffies < maxjif; )
  2271. +            if (mfp.par_dt_reg & 0x20) return( 1 );
  2272. +    }
  2273. +    else {
  2274. +        long tries = loops_per_sec * timeout / HZ / 8;
  2275. +        while( tries-- >= 0 )
  2276. +            if (mfp.par_dt_reg & 0x20) return( 1 );
  2277. +    }        
  2278. +    return( 0 ); /* timeout! */
  2279. +}
  2280. +
  2281. +
  2282. +/* Send one data byte over the bus and set mode for next operation
  2283. + * with one move.l -- Atari recommends this...
  2284. + */
  2285. +
  2286. +#define DMA_LONG_WRITE(data,mode)                                                \
  2287. +    do {                                                                        \
  2288. +        *((unsigned long *)&dma_wd.fdc_acces_seccount) = ((data)<<16) | (mode);    \
  2289. +    } while(0)
  2290. +
  2291. +
  2292. +/* acsicmd_dma() sends an ACSI command and sets up the DMA to transfer
  2293. + * 'blocks' blocks of 512 bytes from/to 'buffer'.
  2294. + * Because the _IRQ signal is used for handshaking the command bytes,
  2295. + * the ACSI interrupt has to be disabled in this function. If the end
  2296. + * of the operation should be signalled by a real interrupt, it has to be
  2297. + * reenabled afterwards.
  2298. + */
  2299. +
  2300. +static int acsicmd_dma( const char *cmd, char *buffer, int blocks, int rwflag )
  2301. +
  2302. +{    unsigned long    flags, paddr;
  2303. +    int                i;
  2304. +
  2305. +#ifdef NO_WRITE
  2306. +    if (rwflag || *cmd == 0x0a) {
  2307. +        printk( "ACSI: Write commands disabled!\n" );
  2308. +        return( 0 );
  2309. +    }
  2310. +#endif
  2311. +    
  2312. +    rwflag = rwflag ? 0x100 : 0;
  2313. +    paddr = VTOP( buffer );
  2314. +
  2315. +    DISABLE_IRQ();
  2316. +
  2317. +    save_flags(flags);  
  2318. +    cli();
  2319. +    /* Low on A1 */
  2320. +    dma_wd.dma_mode_status = 0x88 | rwflag;
  2321. +    nop(); nop();
  2322. +
  2323. +    /* set DMA address */
  2324. +    dma_wd.dma_lo = (unsigned char)paddr;
  2325. +    paddr >>= 8;
  2326. +    nop();
  2327. +    dma_wd.dma_md = (unsigned char)paddr;
  2328. +    paddr >>= 8;
  2329. +    nop();
  2330. +    dma_wd.dma_hi = (unsigned char)paddr;
  2331. +    nop();
  2332. +    restore_flags(flags);
  2333. +
  2334. +    /* send the command bytes except the last */
  2335. +    for( i = 0; i < 5; ++i ) {
  2336. +        DMA_LONG_WRITE( *cmd++, 0x8a | rwflag );
  2337. +        udelay(20);
  2338. +        if (!wait_for_IRQ( HZ/2 )) return( 0 ); /* timeout */
  2339. +    }
  2340. +
  2341. +    /* Clear FIFO and switch DMA to correct direction */  
  2342. +    dma_wd.dma_mode_status = 0x90 | (rwflag ^ 0x100);  
  2343. +    nop();
  2344. +    dma_wd.dma_mode_status = 0x90 | rwflag;
  2345. +    nop();
  2346. +
  2347. +    /* How many sectors for DMA */
  2348. +    dma_wd.fdc_acces_seccount = blocks;
  2349. +    nop();
  2350. +    
  2351. +    /* send last command byte */
  2352. +    dma_wd.dma_mode_status = 0x8a | rwflag;
  2353. +    nop();
  2354. +    DMA_LONG_WRITE( *cmd++, 0x0a | rwflag );
  2355. +    udelay(80);
  2356. +
  2357. +    return( 1 );
  2358. +    /* Note that the ACSI interrupt is still disabled after this
  2359. +     * function. If you want to get the IRQ delivered, enable it manually!
  2360. +     */
  2361. +}
  2362. +
  2363. +
  2364. +/*
  2365. + * acsicmd_nodma() sends an ACSI command that requires no DMA.
  2366. + */
  2367. +
  2368. +static int acsicmd_nodma( const char *cmd )
  2369. +
  2370. +{    int    i;
  2371. +
  2372. +    DISABLE_IRQ();
  2373. +
  2374. +    /* send first command byte */
  2375. +    dma_wd.dma_mode_status = 0x88;
  2376. +    nop(); nop();
  2377. +    DMA_LONG_WRITE( *cmd++, 0x8a );
  2378. +    udelay(20);
  2379. +    if (!wait_for_IRQ( HZ/2 )) return( 0 ); /* timeout */
  2380. +
  2381. +    /* send the intermediate command bytes */
  2382. +    for( i = 0; i < 4; ++i ) {
  2383. +        DMA_LONG_WRITE( *cmd++, 0x8a );
  2384. +        udelay(20);
  2385. +        if (!wait_for_IRQ( HZ/2 )) return( 0 ); /* timeout */
  2386. +    }
  2387. +
  2388. +    /* send last command byte */
  2389. +    DMA_LONG_WRITE( *cmd++, 0x0a );
  2390. +    udelay(80);
  2391. +    
  2392. +    return( 1 );
  2393. +    /* Note that the ACSI interrupt is still disabled after this
  2394. +     * function. If you want to get the IRQ delivered, enable it manually!
  2395. +     */
  2396. +}
  2397. +
  2398. +
  2399. +#ifdef DEBUG
  2400. +
  2401. +/* REQUEST SENSE is called only when DEBUG is defined to better
  2402. + * specify the error that occured.
  2403. + * Under normal circumstances, the exact error reason doesn't matter
  2404. + * and this function isn't needed.
  2405. + */
  2406. +
  2407. +static int acsi_reqsense( char *buffer )
  2408. +
  2409. +{
  2410. +    if (!acsicmd_dma( reqsense_cmd, buffer, 1, 0 )) return( 0 );
  2411. +    if (!wait_for_IRQ( 10 )) return( 0 );
  2412. +    acsi_getstatus();
  2413. +    udelay(100);
  2414. +    if (!acsicmd_nodma( reqsense_cmd )) return( 0 );
  2415. +    if (!wait_for_IRQ( 10 )) return( 0 );
  2416. +    acsi_getstatus();
  2417. +    udelay(100);
  2418. +    if (!acsicmd_nodma( reqsense_cmd )) return( 0 );
  2419. +    if (!wait_for_IRQ( 10 )) return( 0 );
  2420. +    acsi_getstatus();
  2421. +    udelay(100);
  2422. +    if (!acsicmd_nodma( reqsense_cmd )) return( 0 );
  2423. +    if (!wait_for_IRQ( 10 )) return( 0 );
  2424. +    acsi_getstatus();
  2425. +    cache_clear( VTOP(buffer), 16 );
  2426. +    
  2427. +    return( 1 );
  2428. +}    
  2429. +
  2430. +#endif
  2431. +
  2432. +
  2433. +/*
  2434. + * ACSI status phase: get the status byte from the bus
  2435. + *
  2436. + * I've seen several times that a 0xff status is read, propably due to
  2437. + * a timing error. In this case, the procedure is repeated after the
  2438. + * next _IRQ edge.
  2439. + */
  2440. +
  2441. +static int acsi_getstatus( void )
  2442. +
  2443. +{    int    status;
  2444. +
  2445. +    for(;;) {
  2446. +        if (!wait_for_IRQ( 40 )) return( -1 );
  2447. +        dma_wd.dma_mode_status = 0x8a;
  2448. +        nop(); nop();
  2449. +        status = dma_wd.fdc_acces_seccount;
  2450. +        if (status != 0xff) break;
  2451. +#ifdef DEBUG
  2452. +        printk("ACSI: skipping 0xff status byte\n" );
  2453. +#endif
  2454. +        udelay(40);
  2455. +        wait_for_noIRQ( 20 );
  2456. +    }
  2457. +    dma_wd.dma_mode_status = 0x80;
  2458. +    udelay(40);
  2459. +    wait_for_noIRQ( 20 );
  2460. +
  2461. +    return( status & 0x1f ); /* mask of the device# */
  2462. +}
  2463. +
  2464. +
  2465. +#if 0
  2466. +
  2467. +/* Receive data in an extended status phase. Never needed... */
  2468. +
  2469. +static int acsi_extstatus( char *buffer, int cnt )
  2470. +
  2471. +{    int    status, i = 0;
  2472. +
  2473. +    udelay(80);
  2474. +    while( cnt-- >= 0 ) {
  2475. +        if (!wait_for_IRQ( 40 )) return( 0 );
  2476. +        dma_wd.dma_mode_status = 0x8a;
  2477. +        nop(); nop();
  2478. +        status = dma_wd.fdc_acces_seccount;
  2479. +        *buffer++ = status & 0xff;
  2480. +        udelay(80);
  2481. +    }
  2482. +    return( 1 );
  2483. +}
  2484. +
  2485. +#endif
  2486. +
  2487. +
  2488. +static void acsi_print_error( const unsigned char *errblk )
  2489. +
  2490. +{    int i, errcode = errblk[0] & 0x7f;
  2491. +    
  2492. +    printk( "ACSI error 0x%02x", errcode );
  2493. +    if (errblk[0] & 0x80)
  2494. +        printk( " for sector %d",
  2495. +                ((errblk[1] & 0x1f) << 16) |
  2496. +                (errblk[2] << 8) | errblk[0] );
  2497. +    for( i = sizeof(acsi_errors)/sizeof(*acsi_errors)-1; i >= 0; --i )
  2498. +        if (acsi_errors[i].code == errcode) break;
  2499. +    if (i >= 0)
  2500. +        printk( ": %s\n", acsi_errors[i].text );
  2501. +}
  2502. +
  2503. +
  2504. +
  2505. +
  2506. +/*******************************************************************
  2507. + *
  2508. + * ACSI interrupt routine
  2509. + *   Test, if this is a ACSI interrupt and call the irq handler
  2510. + *   Otherwise ignore this interrupt.
  2511. + *
  2512. + *******************************************************************/
  2513. +
  2514. +static void acsi_interrupt( struct intframe *fp, void *data )
  2515. +
  2516. +{    void (*acsi_irq_handler)(void) = DEVICE_INTR;
  2517. +
  2518. +    DEVICE_INTR = NULL;
  2519. +    CLEAR_TIMER();
  2520. +
  2521. +    if (!acsi_irq_handler)
  2522. +        acsi_irq_handler = unexpected_acsi_interrupt;
  2523. +    acsi_irq_handler();
  2524. +}
  2525. +
  2526. +
  2527. +/******************************************************************
  2528. + *
  2529. + * The Interrupt handlers
  2530. + *
  2531. + *******************************************************************/
  2532. +
  2533. +
  2534. +static void unexpected_acsi_interrupt( void )
  2535. +
  2536. +{
  2537. +    printk("Unexpected ACSI interrupt\n");
  2538. +}
  2539. +
  2540. +
  2541. +/* This function is called in case of errors. Because we cannot reset
  2542. + * the ACSI bus or a single device, there is no other choice than
  2543. + * retrying several times :-(
  2544. + */
  2545. +
  2546. +static void bad_rw_intr( void )
  2547. +
  2548. +{
  2549. +    if (!CURRENT)
  2550. +        return;
  2551. +
  2552. +    if (++CURRENT->errors >= MAX_ERRORS)
  2553. +        end_request(0);
  2554. +    /* Otherwise just retry */
  2555. +}
  2556. +
  2557. +
  2558. +static void read_intr( void )
  2559. +
  2560. +{    int        status;
  2561. +    
  2562. +    status = acsi_getstatus();
  2563. +    if (status != 0) {
  2564. +        printk( "ad%c: ", DEVICE_NR(MINOR(CURRENT->dev))+'a' );
  2565. +        if (!acsi_reqsense( acsi_buffer ))
  2566. +            printk( "ACSI error and REQUEST SENSE failed (status=0x%02x)\n", status );
  2567. +        else {
  2568. +            acsi_print_error( acsi_buffer );
  2569. +            if ((*acsi_buffer & 0x7f) == 0x28)
  2570. +                acsi_info[DEVICE_NR(MINOR(CURRENT->dev))].changed = 1;
  2571. +        }
  2572. +        ENABLE_IRQ();
  2573. +        bad_rw_intr();
  2574. +        redo_acsi_request();
  2575. +        return;
  2576. +    }
  2577. +
  2578. +    cache_clear( VTOP(CurrentBuffer), CurrentNSect*512 );
  2579. +    if (CurrentBuffer == acsi_buffer)
  2580. +        copy_from_acsibuffer();
  2581. +
  2582. +    do_end_requests();
  2583. +    redo_acsi_request();
  2584. +}
  2585. +
  2586. +
  2587. +static void write_intr(void)
  2588. +
  2589. +{    int    status;
  2590. +
  2591. +    status = acsi_getstatus();
  2592. +    if (status != 0) {
  2593. +        printk( "ad%c: ", DEVICE_NR(MINOR(CURRENT->dev))+'a' );
  2594. +        if (!acsi_reqsense( acsi_buffer ))
  2595. +            printk( "ACSI error and REQUEST SENSE failed (status=0x%02x)\n", status );
  2596. +        else {
  2597. +            acsi_print_error( acsi_buffer );
  2598. +            if ((*acsi_buffer & 0x7f) == 0x28)
  2599. +                acsi_info[DEVICE_NR(MINOR(CURRENT->dev))].changed = 1;
  2600. +        }
  2601. +        bad_rw_intr();
  2602. +        redo_acsi_request();
  2603. +        return;
  2604. +    }
  2605. +
  2606. +    do_end_requests();
  2607. +    redo_acsi_request();
  2608. +}
  2609. +
  2610. +
  2611. +static void acsi_times_out( unsigned long dummy )
  2612. +
  2613. +{
  2614. +    DEVICE_INTR = NULL;
  2615. +    printk("ACSI timeout\n");
  2616. +    if (!CURRENT) return;
  2617. +    if (++CURRENT->errors >= MAX_ERRORS) {
  2618. +#ifdef DEBUG
  2619. +        printk("ACSI: too many errors.\n");
  2620. +#endif
  2621. +        end_request(0);
  2622. +    }
  2623. +
  2624. +    redo_acsi_request();
  2625. +}
  2626. +
  2627. +
  2628. +
  2629. +/***********************************************************************
  2630. + *
  2631. + *  Scatter-gather utility functions
  2632. + *
  2633. + ***********************************************************************/
  2634. +
  2635. +
  2636. +static void copy_to_acsibuffer( void )
  2637. +
  2638. +{    int                    i;
  2639. +    char                *src, *dst;
  2640. +    struct buffer_head    *bh;
  2641. +    
  2642. +    src = CURRENT->buffer;
  2643. +    dst = acsi_buffer;
  2644. +    bh = CURRENT->bh;
  2645. +
  2646. +    if (!bh)
  2647. +        memcpy( dst, src, CurrentNSect*512 );
  2648. +    else
  2649. +        for( i = 0; i < CurrentNReq; ++i ) {
  2650. +            memcpy( dst, src, bh->b_size );
  2651. +            dst += bh->b_size;
  2652. +            if ((bh = bh->b_reqnext))
  2653. +                src = bh->b_data;
  2654. +        }
  2655. +}
  2656. +
  2657. +
  2658. +static void copy_from_acsibuffer( void )
  2659. +
  2660. +{    int                    i;
  2661. +    char                *src, *dst;
  2662. +    struct buffer_head    *bh;
  2663. +    
  2664. +    dst = CURRENT->buffer;
  2665. +    src = acsi_buffer;
  2666. +    bh = CURRENT->bh;
  2667. +
  2668. +    if (!bh)
  2669. +        memcpy( dst, src, CurrentNSect*512 );
  2670. +    else
  2671. +        for( i = 0; i < CurrentNReq; ++i ) {
  2672. +            memcpy( dst, src, bh->b_size );
  2673. +            src += bh->b_size;
  2674. +            if ((bh = bh->b_reqnext))
  2675. +                dst = bh->b_data;
  2676. +        }
  2677. +}
  2678. +
  2679. +
  2680. +static void do_end_requests( void )
  2681. +
  2682. +{    int        i, n;
  2683. +
  2684. +    if (!CURRENT->bh) {
  2685. +        CURRENT->nr_sectors -= CurrentNSect;
  2686. +        CURRENT->current_nr_sectors -= CurrentNSect;
  2687. +        CURRENT->sector += CurrentNSect;
  2688. +        if (CURRENT->nr_sectors == 0)
  2689. +            end_request(1);
  2690. +    }
  2691. +    else {
  2692. +        for( i = 0; i < CurrentNReq; ++i ) {
  2693. +            n = CURRENT->bh->b_size >> 9;
  2694. +            CURRENT->nr_sectors -= n;
  2695. +            CURRENT->current_nr_sectors -= n;
  2696. +            CURRENT->sector += n;
  2697. +            end_request(1);
  2698. +        }
  2699. +    }
  2700. +}
  2701. +
  2702. +
  2703. +
  2704. +
  2705. +/***********************************************************************
  2706. + *
  2707. + *  do_acsi_request and friends
  2708. + *
  2709. + ***********************************************************************/
  2710. +
  2711. +static void do_acsi_request( void )
  2712. +
  2713. +{
  2714. +    stdma_lock( acsi_interrupt, NULL );
  2715. +    redo_acsi_request();
  2716. +}
  2717. +
  2718. +
  2719. +static void redo_acsi_request( void )
  2720. +
  2721. +{    unsigned            block, dev, target, lun, nsect;
  2722. +    char                 *buffer;
  2723. +    unsigned long        pbuffer;
  2724. +    struct buffer_head    *bh;
  2725. +    
  2726. +    TEST_PAGE("redo_acsi_request",0);
  2727. +    
  2728. +    if (CURRENT && CURRENT->dev < 0) {
  2729. +        if (!DEVICE_INTR) stdma_release();
  2730. +        return;
  2731. +    }
  2732. +
  2733. +    if (DEVICE_INTR)
  2734. +        return;
  2735. +
  2736. +  repeat:
  2737. +    CLEAR_TIMER();
  2738. +    /* Another check here: An interrupt or timer event could have
  2739. +     * happened since the last check!
  2740. +     */
  2741. +    if (CURRENT && CURRENT->dev < 0) {
  2742. +        if (!DEVICE_INTR) stdma_release();
  2743. +        return;
  2744. +    }
  2745. +    if (DEVICE_INTR)
  2746. +        return;
  2747. +
  2748. +    if (!CURRENT) {
  2749. +        CLEAR_INTR;
  2750. +        stdma_release();
  2751. +        return;
  2752. +    }
  2753. +    
  2754. +    if (MAJOR(CURRENT->dev) != MAJOR_NR)
  2755. +        panic(DEVICE_NAME ": request list destroyed");
  2756. +    if (CURRENT->bh) {
  2757. +        if (!CURRENT->bh->b_lock)
  2758. +            panic(DEVICE_NAME ": block not locked");
  2759. +    }
  2760. +
  2761. +    dev = MINOR(CURRENT->dev);
  2762. +    block = CURRENT->sector;
  2763. +    if (DEVICE_NR(dev) >= NDevices ||
  2764. +        block+CURRENT->nr_sectors >= acsi_part[dev].nr_sects) {
  2765. +#ifdef DEBUG
  2766. +        printk( "ad%c: attempted access for block %d past end of device at block %ld.\n",
  2767. +                DEVICE_NR(dev)+'a', block, acsi_part[dev].nr_sects);
  2768. +#endif
  2769. +        end_request(0);
  2770. +        goto repeat;
  2771. +    }
  2772. +    if (acsi_info[DEVICE_NR(dev)].changed) {
  2773. +        printk( "ad%c: request denied because cartridge has been changed.\n",
  2774. +                DEVICE_NR(dev)+'a' );
  2775. +        end_request(0);
  2776. +        goto repeat;
  2777. +    }
  2778. +    
  2779. +    block += acsi_part[dev].start_sect;
  2780. +    target = acsi_info[DEVICE_NR(dev)].target;
  2781. +    lun    = acsi_info[DEVICE_NR(dev)].lun;
  2782. +
  2783. +    /* Find out how many sectors should be transferred from/to
  2784. +     * consecutive buffers and thus can be done with a single command.
  2785. +     */
  2786. +    buffer      = CURRENT->buffer;
  2787. +    pbuffer     = VTOP(buffer);
  2788. +    nsect       = CURRENT->current_nr_sectors;
  2789. +    CurrentNReq = 1;
  2790. +
  2791. +    if ((bh = CURRENT->bh) && bh != CURRENT->bhtail) {
  2792. +        if (!STRAM_ADDR(pbuffer)) {
  2793. +            /* If transfer is done via the ACSI buffer anyway, we can
  2794. +             * assemble as much bh's as fit in the buffer.
  2795. +             */
  2796. +            while( (bh = bh->b_reqnext) ) {
  2797. +                if (nsect + (bh->b_size>>9) > ACSI_BUFFER_SECTORS) break;
  2798. +                nsect += bh->b_size >> 9;
  2799. +                ++CurrentNReq;
  2800. +                if (bh == CURRENT->bhtail) break;
  2801. +            }
  2802. +            buffer = acsi_buffer;
  2803. +        }
  2804. +        else {
  2805. +            unsigned long pendadr, pnewadr;
  2806. +            pendadr = pbuffer + nsect*512;
  2807. +            while( (bh = bh->b_reqnext) ) {
  2808. +                pnewadr = VTOP(bh->b_data);
  2809. +                if (!STRAM_ADDR(pnewadr) || pendadr != pnewadr) break;
  2810. +                nsect += bh->b_size >> 9;
  2811. +                pendadr += pnewadr + bh->b_size;
  2812. +                ++CurrentNReq;
  2813. +                if (bh == CURRENT->bhtail) break;
  2814. +            }
  2815. +        }
  2816. +    }
  2817. +    else {
  2818. +        if (!STRAM_ADDR(pbuffer)) {
  2819. +            buffer = acsi_buffer;
  2820. +            if (nsect > ACSI_BUFFER_SECTORS)
  2821. +                nsect = ACSI_BUFFER_SECTORS;
  2822. +        }
  2823. +    }
  2824. +    CurrentBuffer = buffer;
  2825. +    CurrentNSect  = nsect;
  2826. +    
  2827. +    if (CURRENT->cmd == WRITE) {
  2828. +        CMDSET_TARG_LUN( write_cmd, target, lun );
  2829. +        CMDSET_BLOCK( write_cmd, block );
  2830. +        CMDSET_LEN( write_cmd, nsect );
  2831. +        if (buffer == acsi_buffer)
  2832. +            copy_to_acsibuffer();
  2833. +        cache_push( pbuffer, nsect*512 );
  2834. +        if (!acsicmd_dma( write_cmd, buffer, nsect, 1 )) {
  2835. +            printk( "ACSI: Timeout in command block\n" );
  2836. +            udelay(200);    /* wait some time between commands to let
  2837. +                             * things settle down... */
  2838. +            bad_rw_intr();
  2839. +            goto repeat;
  2840. +        }
  2841. +        SET_INTR(write_intr);
  2842. +        SET_TIMER();
  2843. +        ENABLE_IRQ();
  2844. +        return;
  2845. +    }
  2846. +    if (CURRENT->cmd == READ) {
  2847. +        CMDSET_TARG_LUN( read_cmd, target, lun );
  2848. +        CMDSET_BLOCK( read_cmd, block );
  2849. +        CMDSET_LEN( read_cmd, nsect );
  2850. +        if (!acsicmd_dma( read_cmd, buffer, nsect, 0 )) {
  2851. +            printk( "ACSI: Timeout in command block\n" );
  2852. +            udelay(200);    /* wait some time between commands to let
  2853. +                             * things settle down... */
  2854. +            bad_rw_intr();
  2855. +            goto repeat;
  2856. +        }
  2857. +        SET_INTR(read_intr);
  2858. +        SET_TIMER();
  2859. +        ENABLE_IRQ();
  2860. +        return;
  2861. +    }
  2862. +    panic("unknown ACSI command");
  2863. +}
  2864. +
  2865. +
  2866. +
  2867. +/***********************************************************************
  2868. + *
  2869. + *  Misc functions: ioctl, open, release, check_change, ...
  2870. + *
  2871. + ***********************************************************************/
  2872. +
  2873. +
  2874. +static int acsi_ioctl( struct inode *inode, struct file *file,
  2875. +                       unsigned int cmd, unsigned long arg )
  2876. +{    int dev, err;
  2877. +
  2878. +    if (!inode)
  2879. +        return -EINVAL;
  2880. +    dev = DEVICE_NR(MINOR(inode->i_rdev));
  2881. +    if (dev >= NDevices)
  2882. +        return -EINVAL;
  2883. +    switch (cmd) {
  2884. +        /* I left out the GETGEO cmd; This doesn't make much sense for
  2885. +         * ACSI disks...
  2886. +         */
  2887. +      case BLKGETSIZE:   /* Return device size */
  2888. +        if (!arg)  return -EINVAL;
  2889. +        err = verify_area(VERIFY_WRITE, (long *) arg, sizeof(long));
  2890. +        if (err)
  2891. +            return err;
  2892. +        put_fs_long(acsi_part[MINOR(inode->i_rdev)].nr_sects,
  2893. +                    (long *) arg);
  2894. +        return 0;
  2895. +      case BLKFLSBUF:
  2896. +        if(!suser())  return -EACCES;
  2897. +        if(!inode->i_rdev) return -EINVAL;
  2898. +        fsync_dev(inode->i_rdev);
  2899. +        invalidate_buffers(inode->i_rdev);
  2900. +        return 0;
  2901. +
  2902. +      case BLKRRPART: /* Re-read partition tables */
  2903. +        return revalidate_acsidisk(inode->i_rdev, 1);
  2904. +      RO_IOCTLS(inode->i_rdev,arg);
  2905. +      default:
  2906. +        return -EINVAL;
  2907. +    }
  2908. +}
  2909. +
  2910. +
  2911. +/*
  2912. + * Open a device, check for read-only and lock the medium if it is
  2913. + * removable.
  2914. + */
  2915. +
  2916. +static int acsi_open( struct inode * inode, struct file * filp )
  2917. +
  2918. +{    int target;
  2919. +    target = DEVICE_NR(MINOR(inode->i_rdev));
  2920. +
  2921. +    while (busy[target])
  2922. +        sleep_on(&busy_wait);
  2923. +
  2924. +    if (access_count[target] == 0 && acsi_info[target].removable) {
  2925. +        check_disk_change( inode->i_rdev );
  2926. +        acsi_prevent_removal( target, 1 );
  2927. +    }
  2928. +    access_count[target]++;
  2929. +
  2930. +    if (filp && filp->f_mode) {
  2931. +        if (filp->f_mode & 2) {
  2932. +            if (acsi_info[target].read_only) {
  2933. +                acsi_release( inode, filp );
  2934. +                return( -EACCES );
  2935. +            }
  2936. +        }
  2937. +    }
  2938. +
  2939. +    return 0;
  2940. +}
  2941. +
  2942. +/*
  2943. + * Releasing a block device means we sync() it, so that it can safely
  2944. + * be forgotten about...
  2945. + */
  2946. +
  2947. +static void acsi_release( struct inode * inode, struct file * file )
  2948. +
  2949. +{    int target;
  2950. +    
  2951. +    sync_dev(inode->i_rdev);
  2952. +
  2953. +    target = DEVICE_NR(MINOR(inode->i_rdev));
  2954. +    if (--access_count[target] == 0 && acsi_info[target].removable)
  2955. +        acsi_prevent_removal( target, 0 );
  2956. +}
  2957. +
  2958. +
  2959. +/*
  2960. + * Prevent or allow a media change for removable devices.
  2961. + */
  2962. +
  2963. +static void acsi_prevent_removal( int target, int flag )
  2964. +
  2965. +{
  2966. +    stdma_lock( NULL, NULL );
  2967. +    
  2968. +    CMDSET_TARG_LUN( pa_med_rem_cmd,
  2969. +                     acsi_info[target].target,
  2970. +                     acsi_info[target].lun );
  2971. +    CMDSET_LEN( pa_med_rem_cmd, flag );
  2972. +    
  2973. +    if (!acsicmd_nodma( pa_med_rem_cmd )) goto the_end;
  2974. +    if (!wait_for_IRQ( 3*HZ )) goto the_end;
  2975. +    acsi_getstatus();
  2976. +    /* Do not report errors -- some devices may not know this command. */
  2977. +
  2978. +  the_end:
  2979. +    ENABLE_IRQ();
  2980. +    stdma_release();
  2981. +}
  2982. +
  2983. +
  2984. +int check_acsi_media_change( int full_dev, int flag )
  2985. +
  2986. +{    int target = DEVICE_NR(MINOR(full_dev));
  2987. +    
  2988. +    if (!acsi_info[target].removable) return( 0 );
  2989. +
  2990. +    if (acsi_info[target].changed)
  2991. +        /* We can be sure that the medium has been changed -- REQUEST
  2992. +         * SENSE has reported this earlier.
  2993. +         */
  2994. +        return( 1 );
  2995. +
  2996. +    /* If the flag isn't set, make a test by reading block 0.
  2997. +     * If errors happen, it seems to be better to say "changed"...
  2998. +     */
  2999. +    stdma_lock( NULL, NULL );
  3000. +    CMDSET_TARG_LUN( read_cmd, acsi_info[target].target, acsi_info[target].lun );
  3001. +    CMDSET_BLOCK( read_cmd, 0 );
  3002. +    CMDSET_LEN( read_cmd, 1 );
  3003. +    if (acsicmd_dma( read_cmd, acsi_buffer, 1, 0 ) &&
  3004. +        wait_for_IRQ( HZ )) {
  3005. +        if (acsi_getstatus()) {
  3006. +            if (acsi_reqsense( acsi_buffer )) {
  3007. +                if ((acsi_buffer[0] & 0x7f) == 0x28)
  3008. +                    acsi_info[target].changed = 1;
  3009. +            }
  3010. +            else {
  3011. +                printk( "ad%c: REQUEST SENSE failed in test for medium change; assuming a change\n",
  3012. +                        target+'a' );
  3013. +                acsi_info[target].changed = 1;
  3014. +            }
  3015. +        }
  3016. +    }
  3017. +    else {
  3018. +        printk( "ad%c: Test for medium changed timed out; assuming a change\n",
  3019. +                target+'a' );
  3020. +        acsi_info[target].changed = 1;
  3021. +    }
  3022. +    ENABLE_IRQ();
  3023. +    stdma_release();
  3024. +
  3025. +    /* Now, after reading a block, the changed status is surely valid. */
  3026. +    return( acsi_info[target].changed );
  3027. +}
  3028. +
  3029. +
  3030. +static int acsi_mode_sense( int target, int lun, SENSE_DATA *sd )
  3031. +
  3032. +{
  3033. +    CMDSET_TARG_LUN( modesense_cmd, target, lun );
  3034. +    if (!acsicmd_dma( modesense_cmd, acsi_buffer, 1, 0 ) ||
  3035. +        !wait_for_IRQ( 3*HZ ) ||
  3036. +        acsi_getstatus() != 0 ||
  3037. +        /* read twice to jump over the second 16-byte border! */
  3038. +        (udelay(300), !wait_for_noIRQ( 20 )) ||
  3039. +        !acsicmd_nodma( modesense_cmd ) ||
  3040. +        !wait_for_IRQ( 3*HZ ) ||
  3041. +        acsi_getstatus() != 0) {
  3042. +        return( 0 );
  3043. +    }
  3044. +
  3045. +    cache_clear( phys_acsi_buffer, sizeof(SENSE_DATA) );
  3046. +    *sd = *(SENSE_DATA *)acsi_buffer;
  3047. +    if (CAPACITY(*sd) == 0) {
  3048. +#ifdef DEBUG
  3049. +        int i;
  3050. +        printk( "Mode sense data for ACSI target %d, lun %d seem not valid:",
  3051. +                target, lun );
  3052. +        for( i = 0; i < sizeof(SENSE_DATA); ++i )
  3053. +            printk( "%02x ", (unsigned char)acsi_buffer[i] );
  3054. +        printk( "\n" );
  3055. +#endif
  3056. +        return( 0 );
  3057. +    }
  3058. +    return( 1 );
  3059. +}
  3060. +
  3061. +
  3062. +
  3063. +/*******************************************************************
  3064. + *
  3065. + *  Initialization
  3066. + *
  3067. + ********************************************************************/
  3068. +
  3069. +
  3070. +static struct gendisk acsi_gendisk = {
  3071. +    MAJOR_NR,            /* Major number */    
  3072. +    "ad",                /* Major name */
  3073. +    4,                    /* Bits to shift to get real from partition */
  3074. +    1 << 4,                /* Number of partitions per real */
  3075. +    MAX_DEV,            /* maximum number of real */
  3076. +    acsi_geninit,        /* init function */
  3077. +    acsi_part,            /* hd struct */
  3078. +    acsi_sizes,            /* block sizes */
  3079. +    0,                    /* number */
  3080. +    (void *)acsi_info,    /* internal */
  3081. +    NULL                /* next */
  3082. +};
  3083. +    
  3084. +
  3085. +static void acsi_geninit( void )
  3086. +
  3087. +{    int             i;
  3088. +    int             target, lun, status;
  3089. +    ACSI_TYPE        type;
  3090. +    int                rmf, rdonly, got_inquiry;
  3091. +    SENSE_DATA        sense;
  3092. +    unsigned long    size;
  3093. +    
  3094. +    printk ("Probing ACSI devices:\n");
  3095. +    NDevices = 0;
  3096. +    stdma_lock( NULL, NULL );
  3097. +
  3098. +    for( target = 0; target < 8 && NDevices < MAX_DEV; ++target ) {
  3099. +
  3100. +        lun = 0;
  3101. +      repeat_for_lun:
  3102. +
  3103. +        /* Do a TEST UNIT READY command to test the presence of a
  3104. +         * device
  3105. +         */
  3106. +        CMDSET_TARG_LUN( tur_cmd, target, lun );
  3107. +        if (!acsicmd_nodma( tur_cmd ))
  3108. +            /* timed out -> no device here */
  3109. +            continue;
  3110. +        status = acsi_getstatus();
  3111. +        if (status) {
  3112. +            if (status == 0x12)
  3113. +                /* The SLM printer should be the only device that
  3114. +                 * responds with the error code in the status byte. In
  3115. +                 * correct status bytes, bit 4 is never set.
  3116. +                 */
  3117. +                printk( "  ID %d, LUN %d: SLM printer (not supported)\n",
  3118. +                        target, lun );
  3119. +            continue;
  3120. +        }
  3121. +
  3122. +        /* Assume default values */
  3123. +        type = HARDDISK;
  3124. +        rmf = 0;
  3125. +        rdonly = 0;
  3126. +        got_inquiry = 0;
  3127. +        printk( "  ID %d, LUN %d: ", target, lun );
  3128. +
  3129. +        /* Do an INQUIRY command to get more infos on this device;
  3130. +         * some older Atari disks don't know about INQUIRY, so use the
  3131. +         * defaults above in case of error...
  3132. +         */
  3133. +        udelay(200);
  3134. +        CMDSET_TARG_LUN( inquiry_cmd, target, lun );
  3135. +        if (acsicmd_dma( inquiry_cmd, acsi_buffer, 1, 0 ) &&
  3136. +            acsi_getstatus() == 0) {
  3137. +
  3138. +            cache_clear( phys_acsi_buffer, 32 );
  3139. +            
  3140. +            switch( acsi_buffer[0] ) {
  3141. +              case 0:
  3142. +                break;
  3143. +              case 5:
  3144. +                type = CDROM;
  3145. +                rdonly = 1;
  3146. +                break;
  3147. +              default:
  3148. +                printk( "Device type not supported (%d)\n", acsi_buffer[0] );
  3149. +                continue;
  3150. +            }
  3151. +            rmf = !!(acsi_buffer[1] & 0x80); /* removable? */
  3152. +            got_inquiry = 1;
  3153. +        }
  3154. +
  3155. +        udelay(200);
  3156. +        if (!acsi_mode_sense( target, lun, &sense )) {
  3157. +            printk( "No mode sense data.\n" );
  3158. +            continue;
  3159. +        }
  3160. +        if (sense.sector_size != 512) {
  3161. +            printk( "Sector size != 512 not supported.\n" );
  3162. +            continue;
  3163. +        }
  3164. +        size = CAPACITY(sense);
  3165. +        if (!got_inquiry) {
  3166. +            /* If INQUIRY wasn't successful, determine the type from
  3167. +             * the sense data.
  3168. +             */
  3169. +            if (sense.format_code == SENSE_FORMAT_CHNG &&
  3170. +                (sense.type & SENSE_TYPE_FIXCHNG_MASK) == SENSE_TYPE_CHNG)
  3171. +                rmf = 1;
  3172. +        }
  3173. +
  3174. +#if 0
  3175. +        /* Read sector 0 (the root sector) to get the media size.
  3176. +         * !! This has to be replaced by some better method! This data
  3177. +         * is only valid for Atari partitioned disks!
  3178. +         */
  3179. +        udelay(200);
  3180. +        CMDSET_TARG_LUN( read_cmd, target, lun );
  3181. +        CMDSET_BLOCK( read_cmd, 0 );
  3182. +        CMDSET_LEN( read_cmd, 1 );
  3183. +        if (!acsicmd_dma( read_cmd, acsi_buffer, 1, 0 ) ||
  3184. +            !wait_for_IRQ( 3*HZ ) ||
  3185. +            acsi_getstatus() != 0) {
  3186. +            printk( "Unreadable\n" );
  3187. +            continue;
  3188. +        }
  3189. +        cache_clear( phys_acsi_buffer, 512 );
  3190. +        size = ((struct rootsector *)acsi_buffer)->hd_siz;
  3191. +#endif
  3192. +        
  3193. +        /* Fill in the acsi_info for this device... */
  3194. +        acsi_info[NDevices].type      = type;
  3195. +        acsi_info[NDevices].target    = target;
  3196. +        acsi_info[NDevices].lun       = lun;
  3197. +        acsi_info[NDevices].removable = rmf;
  3198. +        acsi_info[NDevices].read_only = rdonly;
  3199. +        acsi_info[NDevices].changed   = 0;
  3200. +        acsi_info[NDevices].size      = size;
  3201. +
  3202. +        /* ...and inform the user about it. */
  3203. +        switch( type ) {
  3204. +          case HARDDISK:
  3205. +            printk( "Harddisk " );
  3206. +            break;
  3207. +          case CDROM:
  3208. +            printk( "CD-ROM " );
  3209. +            break;
  3210. +          default:
  3211. +            printk( "Type %d ", (int)type );
  3212. +            break;
  3213. +        }
  3214. +        if (rmf) printk( "(removable) " );
  3215. +        if (rdonly) printk( "(read-only) " );
  3216. +        printk( "%ld MByte\n", (size*512+1024*1024/2)/(1024*1024) );
  3217. +        
  3218. +        NDevices++;
  3219. +
  3220. +        /* If a test for this target was successful, try the next LUN, too */
  3221. +        if (++lun < MAX_LUN)
  3222. +            goto repeat_for_lun;
  3223. +    }
  3224. +
  3225. +    /* reenable interrupt */
  3226. +    ENABLE_IRQ();
  3227. +    stdma_release();
  3228. +
  3229. +    printk( "Found %d ACSI device(s) total.\n", NDevices );
  3230. +                     
  3231. +    for( i = 0; i < NDevices; ++i ) {
  3232. +        acsi_part[i<<4].start_sect = 0;
  3233. +        acsi_part[i<<4].nr_sects = acsi_info[i].size;
  3234. +    }
  3235. +    acsi_gendisk.nr_real = NDevices;
  3236. +    for( i = 0; i < (MAX_DEV << 4); i++ )
  3237. +        acsi_blocksizes[i] = 1024;
  3238. +    blksize_size[MAJOR_NR] = acsi_blocksizes;
  3239. +}
  3240. +
  3241. +
  3242. +static struct file_operations acsi_fops = {
  3243. +    NULL,            /* lseek - default */
  3244. +    block_read,        /* read - general block-dev read */
  3245. +    block_write,    /* write - general block-dev write */
  3246. +    NULL,            /* readdir - bad */
  3247. +    NULL,            /* select */
  3248. +    acsi_ioctl,        /* ioctl */
  3249. +    NULL,            /* mmap */
  3250. +    acsi_open,        /* open */
  3251. +    acsi_release,    /* release */
  3252. +    block_fsync        /* fsync */
  3253. +};
  3254. +
  3255. +
  3256. +unsigned long acsi_init( unsigned long mem_start, unsigned long mem_end )
  3257. +
  3258. +{
  3259. +    if (boot_info.machtype != MACH_ATARI ||
  3260. +        boot_info.bi_atari.model == ATARI_FALCON)
  3261. +        /* Do not init ACSI on a Falcon -- the port is used for SCSI there! */
  3262. +        return( mem_start );
  3263. +
  3264. +    if (register_blkdev( MAJOR_NR, "ad", &acsi_fops )) {
  3265. +        printk( "Unable to get major %d for ACSI\n", MAJOR_NR );
  3266. +        return( mem_start );
  3267. +    }
  3268. +
  3269. +    if (!(acsi_buffer = atari_stram_alloc( ACSI_BUFFER_SIZE, &mem_start ))) {
  3270. +        printk( "Unable to get ACSI ST-Ram buffer.\n" );
  3271. +        return( mem_start );
  3272. +    }
  3273. +    phys_acsi_buffer = VTOP( acsi_buffer );
  3274. +    
  3275. +    blk_dev[MAJOR_NR].request_fn = DEVICE_REQUEST;
  3276. +    read_ahead[MAJOR_NR] = 8;        /* 8 sector (4kB) read-ahead */
  3277. +    acsi_gendisk.next = gendisk_head;
  3278. +    gendisk_head = &acsi_gendisk;
  3279. +
  3280. +    return( mem_start );
  3281. +}
  3282. +
  3283. +
  3284. +#define DEVICE_BUSY busy[target]
  3285. +#define USAGE access_count[target]
  3286. +#define GENDISK_STRUCT acsi_gendisk
  3287. +
  3288. +/*
  3289. + * This routine is called to flush all partitions and partition tables
  3290. + * for a changed scsi disk, and then re-read the new partition table.
  3291. + * If we are revalidating a disk because of a media change, then we
  3292. + * enter with usage == 0.  If we are using an ioctl, we automatically have
  3293. + * usage == 1 (we need an open channel to use an ioctl :-), so this
  3294. + * is our limit.
  3295. + */
  3296. +
  3297. +int revalidate_acsidisk( int dev, int maxusage )
  3298. +
  3299. +{    int target, major;
  3300. +    struct gendisk * gdev;
  3301. +    int max_p;
  3302. +    int start;
  3303. +    int i;
  3304. +    SENSE_DATA sense;
  3305. +    
  3306. +    target =  DEVICE_NR(MINOR(dev));
  3307. +    gdev = &GENDISK_STRUCT;
  3308. +
  3309. +    cli();
  3310. +    if (DEVICE_BUSY || USAGE > maxusage) {
  3311. +        sti();
  3312. +        return -EBUSY;
  3313. +    };
  3314. +    DEVICE_BUSY = 1;
  3315. +    sti();
  3316. +
  3317. +    max_p = gdev->max_p;
  3318. +    start = target << gdev->minor_shift;
  3319. +    major = MAJOR_NR << 8;
  3320. +
  3321. +    for( i = max_p - 1; i >= 0 ; i-- ) {
  3322. +        sync_dev( major | start | i );
  3323. +        invalidate_inodes( major | start | i );
  3324. +        invalidate_buffers( major | start | i );
  3325. +        gdev->part[start+i].start_sect = 0;
  3326. +        gdev->part[start+i].nr_sects = 0;
  3327. +    };
  3328. +
  3329. +#if 0
  3330. +    /* Read sector 0 and look into the partitioning data to get the
  3331. +     * device size.
  3332. +     * !! This has to be replaced sometimes by a better method!
  3333. +     * Not all devices must be partitioned in Atari format!
  3334. +     */
  3335. +    bh = bread( dev, 0, 1024 );
  3336. +    if (!bh) {
  3337. +        printk( "ACSI device %04x: unable to read root sector\n", dev );
  3338. +        acsi_info[target].size = 0x1fffff;
  3339. +    }
  3340. +    else {
  3341. +        acsi_info[target].size = ((struct rootsector *)bh->b_data)->hd_siz;
  3342. +        brelse( bh );
  3343. +    }
  3344. +#else
  3345. +    stdma_lock( NULL, NULL );
  3346. +    if (!acsi_mode_sense( acsi_info[target].target, acsi_info[target].lun, &sense )) {
  3347. +        printk( "ACSI device %04x: mode sense failed.\n", dev );
  3348. +        acsi_info[target].size = 0x1fffff;
  3349. +    }
  3350. +    else {
  3351. +        acsi_info[target].size = CAPACITY(sense);
  3352. +    }
  3353. +    ENABLE_IRQ();
  3354. +    stdma_release();
  3355. +#endif
  3356. +    
  3357. +    acsi_info[target].changed = 0;
  3358. +
  3359. +    gdev->part[start].nr_sects = acsi_info[target].size;
  3360. +    resetup_one_dev( gdev, target );
  3361. +
  3362. +    DEVICE_BUSY = 0;
  3363. +    wake_up(&busy_wait);
  3364. +    return 0;
  3365. +}
  3366. diff -ubr -x RCS -x *.[ao] -x .depend -x .version -x .config -x System.map -x vmlinux -x bootstrap -x *~ -x config.old -x *.orig -x *.rej -x *# -x version.h -x autoconf.h --new-file linux-0.9pl3/drivers/block/amiflop.c linux-0.9pl4/drivers/block/amiflop.c
  3367. --- linux-0.9pl3/drivers/block/amiflop.c    Mon Aug 15 19:20:24 1994
  3368. +++ linux-0.9pl4/drivers/block/amiflop.c    Sat Nov 12 11:35:00 1994
  3369. @@ -44,8 +44,8 @@
  3370.   */
  3371.  #define FD_NODRIVE    0x00000000  /* response when no unit is present */
  3372.  #define FD_DD_3     0xffffffff  /* double-density 3.5" (880K) drive */
  3373. -#define FD_HD_3     0xaaaaaaaa  /* high-density 3.5" (1760K) drive */
  3374. -#define FD_DD_5     0x55555555  /* double-density 5.25" (440K) drive */
  3375. +#define FD_HD_3     0x55555555  /* high-density 3.5" (1760K) drive */
  3376. +#define FD_DD_5     0xaaaaaaaa  /* double-density 5.25" (440K) drive */
  3377.  
  3378.  
  3379.  /*
  3380. @@ -87,6 +87,8 @@
  3381.  
  3382.  /* track buffer */
  3383.  static int savedtrack = -1;
  3384. +static int writepending = 0;
  3385. +static int writefromint = 0;
  3386.  static unsigned char trackdata[MAX_SECTORS * 512];
  3387.  static char *raw_buf;
  3388.  
  3389. @@ -104,10 +106,6 @@
  3390.  static struct wait_queue *fdc_wait = NULL;
  3391.  static struct wait_queue *motor_wait = NULL;
  3392.  
  3393. -#if 0
  3394. -static unsigned int changed_floppies = 0;
  3395. -#endif
  3396. -
  3397.  /*
  3398.   * Functions
  3399.   */
  3400. @@ -138,6 +136,8 @@
  3401.      restore_flags(flags);
  3402.  }
  3403.  
  3404. +static struct timer_list flush_track_timer;
  3405. +
  3406.  static struct timer_list motor_on_timer;
  3407.  static struct timer_list motor_off_timer[FD_MAX_UNITS];
  3408.  static int on_attempts;
  3409. @@ -623,6 +623,8 @@
  3410.          unit[drive].track = -1;
  3411.          selected = -1;
  3412.          savedtrack = -1;
  3413. +        writepending = 0; /* if this was true before, too bad! */
  3414. +        writefromint = 0;
  3415.          return 1;
  3416.      }
  3417.      return 0;
  3418. @@ -688,13 +690,15 @@
  3419.      custom.dsklen = len/sizeof(short) | DSKLEN_DMAEN|DSKLEN_WRITE;
  3420.  
  3421.      block_flag = 2;
  3422. -    while (block_flag == 2)
  3423. -        sleep_on (&wait_fd_block);
  3424. +    return 1;
  3425. +}
  3426.  
  3427. +static void post_write (void)
  3428. +{
  3429.      udelay (2000);   /* 2ms post-write delay */
  3430.      custom.dsklen = 0;
  3431. -
  3432. -    return 1;
  3433. +  writepending = 0;
  3434. +  writefromint = 0;
  3435.  }
  3436.  
  3437.  static int get_track(int drive, int track)
  3438. @@ -719,12 +723,39 @@
  3439.      }
  3440.  }
  3441.  
  3442. +static void flush_track_callback(unsigned long nr)
  3443. +{
  3444. +  writefromint = 1;
  3445. +  amiga_write(nr, (unsigned long)raw_buf, trackdata, savedtrack);
  3446. +  if (!raw_write(nr, savedtrack, raw_buf, unit[nr].type->write_size)) {
  3447. +    printk ("floppy disk write protected\n");
  3448. +    writefromint = 0;
  3449. +    writepending = 0;
  3450. +  }
  3451. +}
  3452. +
  3453. +static int non_int_flush_track (unsigned long nr)
  3454. +{
  3455. +  writefromint = 0;
  3456. +  amiga_write(nr, (unsigned long)raw_buf, trackdata, savedtrack);
  3457. +  if (!raw_write(nr, savedtrack, raw_buf, unit[nr].type->write_size)) {
  3458. +    printk ("floppy disk write protected in write!\n");
  3459. +    writepending = 0;
  3460. +    return 0;
  3461. +  }
  3462. +  while (block_flag == 2)
  3463. +    sleep_on (&wait_fd_block);
  3464. +  post_write();
  3465. +  return 1;
  3466. +}
  3467. +
  3468.  static void redo_fd_request(void)
  3469.  {
  3470.      unsigned int block, track, sector;
  3471.      int device, drive, cnt;
  3472.      struct floppy_struct *floppy;
  3473.      char *data;
  3474. +    unsigned long flags;
  3475.  
  3476.      if (CURRENT && CURRENT->dev < 0) return;
  3477.  
  3478. @@ -760,6 +791,18 @@
  3479.          floppy = unit + drive;
  3480.      }
  3481.  
  3482. +    save_flags (flags);
  3483. +    cli();
  3484. +    if (drive != selected && writepending) {
  3485. +      del_timer (&flush_track_timer);
  3486. +      restore_flags (flags);
  3487. +      if (!non_int_flush_track (selected)) {
  3488. +        end_request(0);
  3489. +        goto repeat;
  3490. +      }
  3491. +    } else
  3492. +      restore_flags (flags);
  3493. +
  3494.      for (cnt = 0; cnt < 2; cnt++) {
  3495.          block = CURRENT->sector + cnt;
  3496.          if ((int)block > floppy->blocks) {
  3497. @@ -771,6 +814,18 @@
  3498.          sector = block - track * floppy->dtype->sects;
  3499.          data = CURRENT->buffer + 512 * cnt;
  3500.  
  3501. +        save_flags (flags);
  3502. +        cli();
  3503. +        if (track != savedtrack && writepending) {
  3504. +          del_timer (&flush_track_timer);
  3505. +          restore_flags (flags);
  3506. +          if (!non_int_flush_track (selected)) {
  3507. +            end_request(0);
  3508. +            goto repeat;
  3509. +          }
  3510. +        } else
  3511. +          restore_flags (flags);
  3512. +
  3513.          switch (CURRENT->cmd) {
  3514.              case READ:
  3515.              if (!motor_on (drive)) {
  3516. @@ -804,16 +859,22 @@
  3517.                  goto repeat;
  3518.              }
  3519.              copy_buffer(data, trackdata + sector * 512);
  3520. -            if (cnt == 1 || track != ((block+1)/floppy->dtype->sects)) {
  3521. -                amiga_write(drive, (unsigned long)raw_buf,
  3522. -                        trackdata, track);
  3523. -                if (!raw_write(drive, track, raw_buf,
  3524. -                           unit[drive].type->write_size)) {
  3525. -                    printk ("floppy disk write protected\n");
  3526. -                    end_request(0);
  3527. -                    goto repeat;
  3528. -                }
  3529. -            }
  3530. +            /*
  3531. +             * setup a callback to write the track buffer
  3532. +             * after a short (1 tick) delay.
  3533. +             */
  3534. +            save_flags (flags);
  3535. +            cli();
  3536. +
  3537. +            if (writepending)
  3538. +                /* reset the timer */
  3539. +                del_timer (&flush_track_timer);
  3540. +                
  3541. +            writepending = 1;
  3542. +            flush_track_timer.data = drive;
  3543. +            flush_track_timer.expires = 1;
  3544. +            add_timer (&flush_track_timer);
  3545. +            restore_flags (flags);
  3546.              break;
  3547.  
  3548.              default:
  3549. @@ -942,7 +1003,7 @@
  3550.      printk("Probing floppy drive(s):\n");
  3551.      for (drive = 0; drive < FD_MAX_UNITS; drive++) {
  3552.          fd_probe(drive);
  3553. -        if (unit[drive].type != FD_NODRIVE)
  3554. +        if (unit[drive].type->code != FD_NODRIVE)
  3555.              printk("Unit %d: %s\n", drive, unit[drive].type->name);
  3556.      }
  3557.  }
  3558. @@ -989,7 +1050,18 @@
  3559.  
  3560.  static void floppy_release(struct inode * inode, struct file * filp)
  3561.  {
  3562. +  unsigned long flags;
  3563. +
  3564.    sync_dev(inode->i_rdev);
  3565. +  save_flags (flags);
  3566. +  cli();
  3567. +  if ((inode->i_rdev & 3) == selected && writepending) {
  3568. +    del_timer (&flush_track_timer);
  3569. +    restore_flags (flags);
  3570. +    non_int_flush_track (selected);
  3571. +  } else
  3572. +    restore_flags (flags);
  3573. +  
  3574.    if (!fd_ref[inode->i_rdev & 3]--) {
  3575.      printk("floppy_release with fd_ref == 0");
  3576.      fd_ref[inode->i_rdev & 3] = 0;
  3577. @@ -1013,9 +1085,18 @@
  3578.  {
  3579.      if (block_flag)
  3580.          custom.dsklen = 0x4000;
  3581. -    block_flag = 0;
  3582.  
  3583. +  block_flag = 0;
  3584.      wake_up (&wait_fd_block);
  3585. +
  3586. +  if (writefromint) {
  3587. +    /* 
  3588. +     * if it was a write from an interrupt,
  3589. +     * we will call post_write from here
  3590. +     */
  3591. +    post_write ();
  3592. +  }
  3593. +
  3594.  }
  3595.  
  3596.  void amiga_floppy_init(void)
  3597. @@ -1043,6 +1124,12 @@
  3598.        unit[i].track = -1;
  3599.    }
  3600.  
  3601. +  flush_track_timer.next = NULL;
  3602. +  flush_track_timer.prev = NULL;
  3603. +  flush_track_timer.expires = 0;
  3604. +  flush_track_timer.data = 0;
  3605. +  flush_track_timer.function = flush_track_callback;
  3606. +  
  3607.    /* blk_size[MAJOR_NR] = floppy_sizes; */
  3608.    blk_dev[MAJOR_NR].request_fn = DEVICE_REQUEST;
  3609.  
  3610. diff -ubr -x RCS -x *.[ao] -x .depend -x .version -x .config -x System.map -x vmlinux -x bootstrap -x *~ -x config.old -x *.orig -x *.rej -x *# -x version.h -x autoconf.h --new-file linux-0.9pl3/drivers/block/amihd.c linux-0.9pl4/drivers/block/amihd.c
  3611. --- linux-0.9pl3/drivers/block/amihd.c    Sun Aug 28 17:24:18 1994
  3612. +++ linux-0.9pl4/drivers/block/amihd.c    Thu Nov 24 20:52:37 1994
  3613. @@ -18,6 +18,8 @@
  3614.   *
  3615.   *
  3616.   *  Modified 1994 for A4000/40 IDE controller support by Torsten Ebeling
  3617. + *
  3618. + *  Modified 16-Nov-1994 to add A1200 IDE controller support by Dwight Engen
  3619.   */
  3620.   
  3621.  /*
  3622. @@ -70,7 +72,11 @@
  3623.  struct hd_i_struct {
  3624.      unsigned int head,sect,cyl,wpcom,lzone,ctl;
  3625.      };
  3626. +struct hd_regs_struct {
  3627. +    unsigned char *hd_data, *hd_error, *hd_nsector, *hd_sector, *hd_lcyl,
  3628. +    *hd_hcyl, *hd_current, *hd_status, *hd_cmd; };
  3629.  static struct hd_i_struct hd_info[] = { {0,0,0,0,0,0},{0,0,0,0,0,0} };
  3630. +static struct hd_regs_struct hd_regs;
  3631.  static int NR_HD = 0;
  3632.  
  3633.  static struct hd_struct hd[MAX_HD<<6]={{0,0},};
  3634. @@ -100,7 +106,7 @@
  3635.           movew a0@,a1@+; \
  3636.           movew a0@,a1@+; \
  3637.           movew a0@,a1@+; \
  3638. -         dbra d6,1b" : : "i" (port), "g" (buf), "g" (nr) : "a0", "a1", "d6");
  3639. +         dbra d6,1b" : : "g" (port), "g" (buf), "g" (nr) : "a0", "a1", "d6");
  3640.  
  3641.  #define port_write(port, buf, nr) \
  3642.  __asm__ __volatile__ \
  3643. @@ -123,7 +129,7 @@
  3644.           movew a1@+,a0@; \
  3645.           movew a1@+,a0@; \
  3646.           movew a1@+,a0@; \
  3647. -         dbra d6,1b" : : "i" (port), "g" (buf), "g" (nr) : "a0", "a1", "d6");
  3648. +         dbra d6,1b" : : "g" (port), "g" (buf), "g" (nr) : "a0", "a1", "d6");
  3649.  
  3650.  void amiga_hd_setup(char *str, int *ints)
  3651.  {
  3652. @@ -143,7 +149,7 @@
  3653.  
  3654.  static int win_result(void)
  3655.  {
  3656. -    int i=inb_p(HD_STATUS);
  3657. +    int i=inb_p(hd_regs.hd_status);
  3658.  
  3659.      if ((i & (BUSY_STAT | READY_STAT | WRERR_STAT | SEEK_STAT | ERR_STAT))
  3660.          == (READY_STAT | SEEK_STAT)) {
  3661. @@ -152,7 +158,7 @@
  3662.      }
  3663.      printk("HD: win_result: status = 0x%02x\n",i);
  3664.      if (i&1) {
  3665. -        hd_error = inb(HD_ERROR);
  3666. +        hd_error = inb(hd_regs.hd_error);
  3667.          printk("HD: win_result: error = 0x%02x\n",hd_error);
  3668.      }    
  3669.      return 1;
  3670. @@ -168,7 +174,7 @@
  3671.      do {
  3672.          if (controller_busy() & BUSY_STAT)
  3673.              return 0;
  3674. -        outb_p(0xA0 | (drive<<4) | head, HD_CURRENT);
  3675. +        outb_p(0xA0 | (drive<<4) | head, hd_regs.hd_current);
  3676.          if (status_ok())
  3677.              return 1;
  3678.      } while (--retry);
  3679. @@ -177,7 +183,7 @@
  3680.  
  3681.  static int status_ok(void)
  3682.  {
  3683. -    unsigned char status = inb_p(HD_STATUS);
  3684. +    unsigned char status = inb_p(hd_regs.hd_status);
  3685.  
  3686.      if (status & BUSY_STAT)
  3687.          return 1;
  3688. @@ -196,7 +202,7 @@
  3689.      unsigned char status;
  3690.  
  3691.      do {
  3692. -        status = inb_p(HD_STATUS);
  3693. +        status = inb_p(hd_regs.hd_status);
  3694.      } while ((status & BUSY_STAT) && --retries);
  3695.      return status;
  3696.  }
  3697. @@ -214,14 +220,18 @@
  3698.          return;
  3699.      }
  3700.      SET_INTR(intr_addr);
  3701. -    outb(hd_info[drive].ctl,HD_CMD);
  3702. -    outb_p(hd_info[drive].wpcom>>2,HD_PRECOMP);
  3703. -    outb_p(nsect,HD_NSECTOR);
  3704. -    outb_p(sect,HD_SECTOR);
  3705. -    outb_p(cyl,HD_LCYL);
  3706. -    outb_p(cyl>>8,HD_HCYL);
  3707. -    outb_p(0xA0|(drive<<4)|head,HD_CURRENT);
  3708. -    outb_p(cmd,HD_COMMAND);
  3709. +    outb(hd_info[drive].ctl,hd_regs.hd_cmd);
  3710. +
  3711. +    /* Note hd_regs.hd_error is precomp on write, but error on read */
  3712. +    outb_p(hd_info[drive].wpcom>>2,hd_regs.hd_error);
  3713. +    outb_p(nsect,hd_regs.hd_nsector);
  3714. +    outb_p(sect,hd_regs.hd_sector);
  3715. +    outb_p(cyl,hd_regs.hd_lcyl);
  3716. +    outb_p(cyl>>8,hd_regs.hd_hcyl);
  3717. +    outb_p(0xA0|(drive<<4)|head,hd_regs.hd_current);
  3718. +
  3719. +    /* Note hd_regs.hd_status is status on read and command on write */
  3720. +    outb_p(cmd,hd_regs.hd_status);
  3721.  }
  3722.  
  3723.  static int drive_busy(void)
  3724. @@ -230,7 +240,7 @@
  3725.      unsigned char c;
  3726.  
  3727.      for (i = 0; i < 500000 ; i++) {
  3728. -        c = inb_p(HD_STATUS);
  3729. +        c = inb_p(hd_regs.hd_status);
  3730.          c &= (BUSY_STAT | READY_STAT | SEEK_STAT);
  3731.          if (c == (READY_STAT | SEEK_STAT))
  3732.              return 0;
  3733. @@ -244,12 +254,12 @@
  3734.      int    i;
  3735.  
  3736.      printk(KERN_DEBUG "HD-controller reset\n");
  3737. -    outb(4,HD_CMD);
  3738. +    outb(4,hd_regs.hd_cmd);
  3739.      for(i = 0; i < 1000; i++) nop();
  3740. -    outb(hd_info[0].ctl & 0x0f ,HD_CMD);
  3741. +    outb(hd_info[0].ctl & 0x0f ,hd_regs.hd_cmd);
  3742.      if (drive_busy())
  3743.          printk("HD-controller still busy\n");
  3744. -    if ((hd_error = inb(HD_ERROR)) != 1)
  3745. +    if ((hd_error = inb(hd_regs.hd_error)) != 1)
  3746.          printk("HD-controller reset failed: %02x\n",hd_error);
  3747.  }
  3748.  
  3749. @@ -315,7 +325,7 @@
  3750.      int retries = 100000;
  3751.  
  3752.      while (--retries > 0)
  3753. -        if (inb_p(HD_STATUS) & DRQ_STAT)
  3754. +        if (inb_p(hd_regs.hd_status) & DRQ_STAT)
  3755.              return 0;
  3756.      return -1;
  3757.  }
  3758. @@ -329,7 +339,7 @@
  3759.      int retries = 100000;
  3760.  
  3761.      do {
  3762. -        i = (unsigned) inb_p(HD_STATUS);
  3763. +        i = (unsigned) inb_p(hd_regs.hd_status);
  3764.          if (i & BUSY_STAT)
  3765.              continue;
  3766.          if ((i & STAT_MASK) != STAT_OK)
  3767. @@ -339,14 +349,14 @@
  3768.      } while (--retries > 0);
  3769.      printk("HD: read_intr: status = 0x%02x\n",i);
  3770.      if (i & ERR_STAT) {
  3771. -        hd_error = (unsigned) inb(HD_ERROR);
  3772. +        hd_error = (unsigned) inb(hd_regs.hd_error);
  3773.          printk("HD: read_intr: error = 0x%02x\n",hd_error);
  3774.      }
  3775.      bad_rw_intr();
  3776.      do_hd_request();
  3777.      return;
  3778.  ok_to_read:
  3779. -    port_read(HD_DATA,CURRENT->buffer,15);
  3780. +    port_read(hd_regs.hd_data,CURRENT->buffer,15);
  3781.      CURRENT->errors = 0;
  3782.      CURRENT->buffer += 512;
  3783.      CURRENT->sector++;
  3784. @@ -363,7 +373,7 @@
  3785.          SET_INTR(&read_intr);
  3786.          return;
  3787.      }
  3788. -    (void) inb_p(HD_STATUS);
  3789. +    (void) inb_p(hd_regs.hd_status);
  3790.  #if (HD_DELAY > 0)
  3791.      last_req = read_timer();
  3792.  #endif
  3793. @@ -377,7 +387,7 @@
  3794.      int retries = 100000;
  3795.  
  3796.      do {
  3797. -        i = (unsigned) inb_p(HD_STATUS);
  3798. +        i = (unsigned) inb_p(hd_regs.hd_status);
  3799.          if (i & BUSY_STAT)
  3800.              continue;
  3801.          if ((i & STAT_MASK) != STAT_OK)
  3802. @@ -387,7 +397,7 @@
  3803.      } while (--retries > 0);
  3804.      printk("HD: write_intr: status = 0x%02x\n",i);
  3805.      if (i & ERR_STAT) {
  3806. -        hd_error = (unsigned) inb(HD_ERROR);
  3807. +        hd_error = (unsigned) inb(hd_regs.hd_error);
  3808.          printk("HD: write_intr: error = 0x%02x\n",hd_error);
  3809.      }
  3810.      bad_rw_intr();
  3811. @@ -402,7 +412,7 @@
  3812.          end_request(1);
  3813.      if (i > 0) {
  3814.        SET_INTR(&write_intr);
  3815. -        port_write(HD_DATA,CURRENT->buffer,15);
  3816. +        port_write(hd_regs.hd_data,CURRENT->buffer,15);
  3817.      } else {
  3818.          do_hd_request();
  3819.      }
  3820. @@ -502,7 +512,7 @@
  3821.              bad_rw_intr();
  3822.              goto repeat;
  3823.          }
  3824. -        port_write(HD_DATA,CURRENT->buffer,15);
  3825. +        port_write(hd_regs.hd_data,CURRENT->buffer,15);
  3826.          return;
  3827.      }
  3828.      if (CURRENT->cmd == READ) {
  3829. @@ -614,17 +624,27 @@
  3830.   ********************************************************/
  3831.  static void hd_interrupt (struct intframe *fp, void *data)
  3832.  {
  3833. +unsigned char ch;
  3834.  void (*hd_irq_handler)(void) = DEVICE_INTR;
  3835.  
  3836. -/* Test, if this is a harddisk interrupt. MSB(0xdd2030) = 1 */
  3837. -if (inb (HD_IRQ_TEST) & 0x80)
  3838. +/* Test, if this is a harddisk interrupt. MSB = 1, hd is source of interrupt */
  3839. +if (boot_info.bi_amiga.model == AMI_4000)
  3840. +  ch = inb(HD_A4000_IRQ);
  3841. +else
  3842. +  ch = inb(HD_A1200_IRQ);
  3843. +  
  3844. +if (ch & 0x80)
  3845.    {
  3846.    DEVICE_INTR = NULL;
  3847.    timer_active &= ~(1 << HD_TIMER);
  3848.  
  3849.    if (!hd_irq_handler)
  3850. +  {
  3851.      hd_irq_handler = unexpected_hd_interrupt;
  3852. -  hd_irq_handler ();
  3853. +  }
  3854. +  hd_irq_handler();
  3855. +  if (boot_info.bi_amiga.model == AMI_1200)
  3856. +    outb(0x7c | (ch & 0x03), HD_A1200_IRQ);
  3857.  
  3858.    return;
  3859.    }
  3860. @@ -646,15 +666,33 @@
  3861.  printk ("Probing harddisk(s):\n");
  3862.  NR_HD = 0;
  3863.  
  3864. -/* Test, if it's an A4000 or an A1200 */
  3865. -if ((boot_info.bi_amiga.model != AMI_4000) && (boot_info.bi_amiga.model != AMI_1200))
  3866. -  {
  3867. +/* Test if an A4000 or an A1200 and setup the base of hd_regs acordingly */
  3868. +if (boot_info.bi_amiga.model == AMI_4000)
  3869. +{
  3870. +  hd_regs.hd_data = (unsigned char *)HD_BASE_A4000;
  3871. +}
  3872. +else if (boot_info.bi_amiga.model == AMI_1200)
  3873. +{
  3874. +  hd_regs.hd_data = (unsigned char *)HD_BASE_A1200;
  3875. +}
  3876. +else /* Not A4000 nor A1200, doesn't have a supported IDE controller */
  3877. +{
  3878.    printk ("IDE harddisk controller not present.\n");
  3879.    hd_gendisk.nr_real = NR_HD;
  3880.    return;
  3881. -  }
  3882. +}
  3883.  
  3884. -outb (IDE_DISABLE_IRQ, HD_CMD);     /* Disable HD-interrupt */
  3885. +/* Now set the rest of hd_regs struct */
  3886. +hd_regs.hd_error    = hd_regs.hd_data + HD_ERROR;
  3887. +hd_regs.hd_nsector    = hd_regs.hd_data + HD_NSECTOR;
  3888. +hd_regs.hd_sector    = hd_regs.hd_data + HD_SECTOR;
  3889. +hd_regs.hd_lcyl        = hd_regs.hd_data + HD_LCYL;
  3890. +hd_regs.hd_hcyl        = hd_regs.hd_data + HD_HCYL;
  3891. +hd_regs.hd_current    = hd_regs.hd_data + HD_CURRENT;
  3892. +hd_regs.hd_status    = hd_regs.hd_data + HD_STATUS;
  3893. +hd_regs.hd_cmd        = hd_regs.hd_data + HD_CMD;
  3894. +
  3895. +outb (IDE_DISABLE_IRQ, hd_regs.hd_cmd);     /* Disable HD-interrupt */
  3896.  cli ();                             /* Disable interrupts   */
  3897.  
  3898.  for (drive=0; drive<2; drive++)
  3899. @@ -667,20 +705,21 @@
  3900.      }
  3901.  
  3902.    /* select drive */
  3903. -  outb_p ((unsigned char) (0xA0 | (drive<<4)), HD_CURRENT);
  3904. +  outb_p ((unsigned char) (0xA0 | (drive<<4)), hd_regs.hd_current);
  3905.  
  3906.    /* Set identify command */
  3907. -  outb_p (WIN_IDENTIFY, HD_COMMAND);
  3908. +  /* Note hd_regs.hd_status is status on read and command on write */
  3909. +  outb_p (WIN_IDENTIFY, hd_regs.hd_status);
  3910.  
  3911.    drive_found = 0;
  3912.    /* Test, if ready to read */
  3913.    for (i=0; i<HD_ID_RETRIES; i++)
  3914.      {
  3915. -    if ((inb_p(HD_STATUS) & (DRQ_STAT|READY_STAT)) == (DRQ_STAT|READY_STAT)) /* ++hn: Detect Seagate drives properly */
  3916. +    if ((inb_p(hd_regs.hd_status) & (DRQ_STAT|READY_STAT)) == (DRQ_STAT|READY_STAT)) /* ++hn: Detect Seagate drives properly */
  3917.        {
  3918.        drive_found = 1;
  3919.  #ifdef DEBUG
  3920. -      printk("hd%d: WIN_IDENTIFY: status = 0x%hx\n", drive, inb_p(HD_STATUS));
  3921. +      printk("hd%d: WIN_IDENTIFY: status = 0x%hx\n", drive, inb_p(hd_regs.hd_status));
  3922.  #endif
  3923.        break;
  3924.        }
  3925. @@ -688,7 +727,7 @@
  3926.    
  3927.    if (drive_found)
  3928.      {
  3929. -    port_read (HD_DATA, Identify, 15);
  3930. +    port_read (hd_regs.hd_data, Identify, 15);
  3931.      for (i=0; i<256; i++)
  3932.        /* We need to swap MSB and LSB */
  3933.        Identify [i] = (Identify [i] << 8) | (Identify [i] >> 8);
  3934. @@ -711,6 +750,7 @@
  3935.      printk ("hd%c not found.\n", (char)drive+'a'); /* ++hn: use hda/hdb naming for the user-messages */
  3936.    }
  3937.  sti ();                             /* Enable interrupts */
  3938. +
  3939.  
  3940.  /* Add the interrupt handler */
  3941.  if (NR_HD)
  3942. diff -ubr -x RCS -x *.[ao] -x .depend -x .version -x .config -x System.map -x vmlinux -x bootstrap -x *~ -x config.old -x *.orig -x *.rej -x *# -x version.h -x autoconf.h --new-file linux-0.9pl3/drivers/block/ataflop.c linux-0.9pl4/drivers/block/ataflop.c
  3943. --- linux-0.9pl3/drivers/block/ataflop.c    Sun Aug 14 10:30:45 1994
  3944. +++ linux-0.9pl4/drivers/block/ataflop.c    Thu Nov 24 21:13:32 1994
  3945. @@ -2,8 +2,40 @@
  3946.   *  linux/kernel/blk_drv/floppy.c
  3947.   *
  3948.   *  Copyright (C) 1993  Greg Harp
  3949. - *  Atari Support by Björn Brauel
  3950. + *  Atari Support by Bjoern Brauel, Roman Hodek
  3951.   *
  3952. + *  Big cleanup Sep 11..14 1994 Roman Hodek:
  3953. + *   - Driver now works interrupt driven
  3954. + *   - Support for two drives; should work, but I cannot test that :-(
  3955. + *   - Reading is done in whole tracks and buffered to speed up things
  3956. + *   - Disk change detection and drive deselecting after motor-off
  3957. + *     similar to TOS
  3958. + *   - Autodetection of disk format (DD/HD); untested yet, because I
  3959. + *     don't have an HD drive :-(
  3960. + *
  3961. + *  Fixes Nov 13 1994 Martin Schaller:
  3962. + *   - Autodetection works now
  3963. + *   - Support for 5 1/4" disks
  3964. + *   - Removed drive type (unknown on atari)
  3965. + *   - Do seeks with 8 Mhz
  3966. + *
  3967. + *  Things left to do:
  3968. + *   - Formatting
  3969. + *   - Maybe a better strategy for disk change detection (does anyone
  3970. + *     know one?)
  3971. + *   - In case of disk errors, don't give up immediatly but retry
  3972. + *     several times
  3973. + *   - There are some strange problems left: The strangest one is
  3974. + *     that, at least on my TT (4+4MB), the first 2 Bytes of the last
  3975. + *     page of the TT-Ram (!) change their contents (some bits get
  3976. + *     set) while a floppy DMA is going on. But there are no accesses
  3977. + *     to these memory locations from the kernel... (I tested that by
  3978. + *     making the page read-only). I cannot explain what's going on...
  3979. + *   - Sometimes the drive-change-detection stops to work. The
  3980. + *     function is still called, but the WP bit always reads as 0...
  3981. + *     Maybe a problem with the status reg mode or a timing problem.
  3982. + *     Note 10/12/94: The change detection now seems to work reliably.
  3983. + *     There is no proof, but I've seen no hang for a long time...
  3984.   */
  3985.  
  3986.  #include <linux/config.h>
  3987. @@ -20,351 +52,950 @@
  3988.  #include <linux/interrupt.h>
  3989.  #include <linux/mm.h>
  3990.  #include <asm/system.h>
  3991. +#include <asm/bitops.h>
  3992.  
  3993.  #include <linux/atarihw.h>
  3994.  #include <linux/atariints.h>
  3995. +#include <linux/atari_stdma.h>
  3996.  
  3997.  #define MAJOR_NR FLOPPY_MAJOR
  3998.  #include "blk.h"
  3999.  
  4000. -#undef __notneeded__
  4001.  
  4002. -/*
  4003. - *  Defines
  4004. +/* Note: FD_MAX_UNITS could be redefined to 2 for the Atari (with
  4005. + * little additional rework in this file). But I'm not yet sure if
  4006. + * some other code depends on the number of floppies... (It is defined
  4007. + * in a public header!)
  4008.   */
  4009. -#define MAX_SECTORS    22
  4010. -#define RAW_BUF     900000
  4011. +#if 0
  4012. +#undef FD_MAX_UNITS
  4013. +#define    FD_MAX_UNITS    2
  4014. +#endif
  4015.  
  4016. -/*
  4017. - *  Error codes
  4018. - */
  4019. -#define FD_OK        0    /* operation succeeded */
  4020. -#define FD_ERROR    -1    /* general error (seek, read, write, etc) */
  4021. -#define FD_NOUNIT    1    /* unit does not exist */
  4022. -#define FD_UNITBUSY    2    /* unit already active */
  4023. -#define FD_NOTACTIVE    3    /* unit is not active */
  4024. -#define FD_NOTREADY    4    /* unit is not ready (motor not on/no disk) */
  4025. +#define TRACKBUFFER 1
  4026. +#undef DEBUG
  4027.  
  4028. -/*
  4029. - *  Floppy ID values
  4030. - */
  4031. -#define FD_NODRIVE    0x00000000  /* response when no unit is present */
  4032. -#define FD_HD_3     0xaaaaaaaa  /* high-density 3.5'' (1760K) drive */
  4033. -#define FD_DD_3     0xbbbbbbbb  /* high-density 3.5'' (880K) drive */
  4034. +/* Disk types: DD or HD */
  4035. +static struct atari_disk_type {
  4036. +    const char    *name;
  4037. +    unsigned    spt;        /* sectors per track */
  4038. +    unsigned    blocks;        /* total number of blocks */
  4039. +    unsigned    fdc_speed;    /* fdc_speed setting */
  4040. +    unsigned     stretch;    /* track doubling ? */
  4041. +} disk_type[] = {
  4042. +    { "d360",  9, 720, 0, 0},    /* 360kB diskette */
  4043. +    { "h1220",15,2400, 3, 0},    /* 1.2MB diskette */
  4044. +    { "D360",  9, 720, 0, 1},    /* 360kb in 720kb drive */
  4045. +    { "D720",  9,1440, 0, 0},    /* 720kb diskette (DD) */    
  4046. +/* the following 2 are only aliases on the atari, since we can't read/write 
  4047. +   with 300kbps */
  4048. +    { "h360",  9, 720, 0, 1},    /* 360kb in 1.2MB drive */
  4049. +    { "h720",  9,1440, 0, 0},    /* 720kb in 1.2MB drive */
  4050. +    { "H1440",18,2880, 3, 0}    /* 1.44MB diskette (HD) */
  4051. +};
  4052.  
  4053. +#define    NUM_DISK_TYPES (sizeof(disk_type)/sizeof(*disk_type))
  4054.  
  4055. -/* Atari: Auto probing not implemented yet! If CONFIG_FLOPPY_DD_ONLY
  4056. - * is not defined, all accesses are done for a HD disk.
  4057. +/* current info on each unit */
  4058. +static struct atari_floppy_struct {
  4059. +    int connected;                /* !=0 : drive is connected */
  4060. +    int autoprobe;                /* !=0 : do autoprobe        */
  4061. +
  4062. +    struct atari_disk_type    *disktype;    /* current type of disk */
  4063. +
  4064. +             int            track;        /* current head position or -1
  4065. +                                         * if unknown */
  4066. +    unsigned int            steprate;    /* steprate setting */
  4067. +    unsigned int            wpstat;        /* current state of WP signal
  4068. +                                         * (for disk change detection) */
  4069. +} unit[FD_MAX_UNITS];
  4070. +
  4071. +
  4072. +#define FDC_READ(reg) ({                        \
  4073. +    /* unsigned long __flags; */                \
  4074. +    unsigned short __val;                        \
  4075. +    /* save_flags(__flags); cli(); */            \
  4076. +    dma_wd.dma_mode_status = 0x80 | (reg);        \
  4077. +    udelay(40);                                    \
  4078. +    __val = dma_wd.fdc_acces_seccount;            \
  4079. +    /* restore_flags(__flags); */                \
  4080. +    __val & 0xff;                                \
  4081. +})
  4082. +
  4083. +#define FDC_WRITE(reg,val)                        \
  4084. +    do {                                        \
  4085. +        /* unsigned long __flags; */            \
  4086. +        /* save_flags(__flags); cli(); */        \
  4087. +        dma_wd.dma_mode_status = 0x80 | (reg);    \
  4088. +        udelay(40);                                \
  4089. +        dma_wd.fdc_acces_seccount = (val);        \
  4090. +        /* restore_flags(__flags); */            \
  4091. +    } while(0)
  4092. +
  4093. +
  4094. +/* Buffering variables:
  4095. + * First, there is a DMA buffer in ST-RAM that is used for floppy DMA
  4096. + * operations. Second, a track buffer is used to cache a whole track
  4097. + * of the disk to save read operations. These are two seperate buffers
  4098. + * because that allows write operations without clearing the track buffer.
  4099.   */
  4100.  
  4101. -/* For Atari, fields rdsz, wrsz, sm, pc1, pc2, sd, st, st unused */
  4102. +#define    MAX_SECTORS    22
  4103.  
  4104. -static struct fd_drive_type drive_types[] = {
  4105. -/*  code    name       tr he   rdsz   wrsz sm pc1 pc2    sd     st    st*/
  4106. - { FD_HD_3,    "HD 3.5", 160, 2, 25000, 25000, 2, 80,161, 3000, 18000, 1000},
  4107. - { FD_DD_3,    "DD 3.5", 160, 2, 25000, 25000, 1, 80,161, 3000, 18000, 1000},
  4108. - { FD_NODRIVE, "No Drive",  0, 0,     0,     0, 0,  0,  0,    0,     0,    0}
  4109. -};
  4110. -#ifdef __notneeded__
  4111. -static int num_dr_types = sizeof(drive_types) / sizeof(drive_types[0]);
  4112. -#endif
  4113. +unsigned char *DMABuffer;              /* buffer for writes */
  4114. +static unsigned long PhysDMABuffer;   /* physical address */
  4115.  
  4116. -static struct fd_data_type data_types[] = {
  4117. -  { "Atari", 9 }
  4118. -};
  4119. -#ifdef __notneeded__
  4120. -static int num_da_types = sizeof(data_types) / sizeof(data_types[0]);
  4121. +#ifdef TRACKBUFFER
  4122. +unsigned char *TrackBuffer;              /* buffer for reads */
  4123. +static unsigned long PhysTrackBuffer; /* physical address */
  4124. +static int BufferDrive, BufferSide, BufferTrack;
  4125. +static int error_drive, error_side, error_track;
  4126. +
  4127. +#define    SECTOR_BUFFER(sec)    (TrackBuffer + ((sec)-1)*512)
  4128. +#define    IS_BUFFERED(drive,side,track) \
  4129. +    (BufferDrive == (drive) && BufferSide == (side) && BufferTrack == (track))
  4130.  #endif
  4131.  
  4132. -
  4133. -/* current info on each unit */
  4134. -static struct floppy_struct unit[FD_MAX_UNITS];
  4135. -
  4136. -/* track buffer */
  4137. -static int savedtrack = -1;
  4138. -unsigned char *trackdata; /* allocated by atari_stram_alloc */
  4139. -
  4140.  /*
  4141.   * These are global variables, as that's the easiest way to give
  4142.   * information to interrupts. They are the data used for the current
  4143.   * request.
  4144.   */
  4145. -static char block_flag = 0;
  4146. -static int selected = 0;
  4147. -static struct wait_queue *wait_on_floppy_select = NULL;
  4148. -static struct wait_queue *wait_fd_block = NULL;
  4149. +static int SelectedDrive = 0;
  4150. +static int ReqCmd, ReqBlock;
  4151. +static int ReqSide, ReqTrack, ReqSector, ReqCnt;
  4152. +static int HeadSettleFlag = 0;
  4153. +static unsigned char *ReqData, *ReqBuffer;
  4154. +static int MotorOn = 0, MotorOffTrys;
  4155.  
  4156.  /* Synchronization of FDC access. */
  4157. -#ifdef __notneeded__
  4158.  static volatile int fdc_busy = 0;
  4159.  static struct wait_queue *fdc_wait = NULL;
  4160. -static struct wait_queue *motor_wait = NULL;
  4161. +
  4162. +static unsigned int changed_floppies = 0xff, fake_change = 0;
  4163. +#define    CHECK_CHANGE_DELAY    HZ/2
  4164. +
  4165. +#define    FD_MOTOR_OFF_DELAY    (3*HZ)
  4166. +#define    FD_MOTOR_OFF_MAXTRY    (10*20)
  4167. +
  4168. +#define    START_MOTOR_OFF_TIMER(delay)            \
  4169. +    do {                                        \
  4170. +        motor_off_timer.expires = (delay);        \
  4171. +        add_timer( &motor_off_timer );            \
  4172. +        MotorOffTrys = 0;                        \
  4173. +    } while(0)
  4174. +
  4175. +#define    START_CHECK_CHANGE_TIMER(delay)                            \
  4176. +    do {                                                        \
  4177. +        timer_table[FLOPPY_TIMER].expires = jiffies + (delay);    \
  4178. +        timer_active |= (1 << FLOPPY_TIMER);                    \
  4179. +    } while(0)
  4180. +
  4181. +
  4182. +/*
  4183. + * The driver is trying to determine the correct media format
  4184. + * while Probing is set. fd_rwsec_done() clears it after a
  4185. + * successful access.
  4186. + */
  4187. +static int Probing = 0;
  4188. +
  4189. +/* This flag is set when a dummy seek is necesary to make the WP
  4190. + * status bit accessible.
  4191. + */
  4192. +static int NeedSeek = 0;
  4193. +
  4194. +
  4195. +#ifdef DEBUG
  4196. +#define DPRINT(a)    printk a
  4197. +#else
  4198. +#define DPRINT(a)
  4199.  #endif
  4200.  
  4201.  #if 0
  4202. -static unsigned int changed_floppies = 0;
  4203. +
  4204. +unsigned long RCont = 0;
  4205. +
  4206. +#define TEST_PAGE(str,adr)                                            \
  4207. +    do {                                                            \
  4208. +        if (*(unsigned long *)0xc03ff000 != RCont) {                \
  4209. +            printk("*0xc03ff000 = %08lx mem_map[]=%d\n",               \
  4210. +                   (RCont = *(unsigned long *)0xc03ff000),            \
  4211. +                   mem_map[MAP_NR(0xc03ff000)] );                    \
  4212. +            printk("%s ",(str));                                    \
  4213. +            printk("%08lx\n",(unsigned long)(adr));                    \
  4214. +        }                                                            \
  4215. +    } while(0)
  4216. +
  4217. +#else
  4218. +
  4219. +#define TEST_PAGE(str,adr) do {} while(0)
  4220. +
  4221.  #endif
  4222.  
  4223. -/*======================================================================
  4224. -  Select the side to use for a particular drive.
  4225. -  The drive must have been calibrated at some point before this.
  4226. -  The drive must also be active and the motor must be running.
  4227. -======================================================================*/
  4228. -#ifdef __notneeded__
  4229. -static void fd_select_side(int drive, int side)
  4230. -{
  4231. -  unsigned long flags;
  4232. +/***************************** Prototypes *****************************/
  4233. +
  4234. +static void fd_select_side( int side );
  4235. +static void fd_select_drive( int drive );
  4236. +static void fd_deselect( void );
  4237. +static void fd_motor_off_timer( unsigned long dummy );
  4238. +static void check_change( void );
  4239. +static __inline__ void set_head_settle_flag( void );
  4240. +static __inline__ int get_head_settle_flag( void );
  4241. +static void floppy_irq( struct intframe *fp, void *data );
  4242. +static void do_fd_action( int drive );
  4243. +static void fd_calibrate( void );
  4244. +static void fd_calibrate_done( int status );
  4245. +static void fd_seek( void );
  4246. +static void fd_seek_done( int status );
  4247. +static void fd_rwsec( void );
  4248. +#ifdef TRACKBUFFER
  4249. +static void fd_readtrack_check( unsigned long dummy );
  4250. +#endif
  4251. +static void fd_rwsec_done( int status );
  4252. +static void finish_fdc( void );
  4253. +static void floppy_off( unsigned int nr);
  4254. +static __inline__ void copy_buffer( void *from, void *to);
  4255. +static void setup_req_params( int drive );
  4256. +static void redo_fd_request( void);
  4257. +static int fd_ioctl( struct inode *inode, struct file *filp, unsigned int
  4258. +                     cmd, unsigned long param);
  4259. +static void fd_probe( int drive );
  4260. +static int fd_test_drive_present( int drive );
  4261. +static void config_types( void );
  4262. +static int floppy_open( struct inode *inode, struct file *filp );
  4263. +static void floppy_release( struct inode * inode, struct file * filp );
  4264. +
  4265. +/************************* End of Prototypes **************************/
  4266. +
  4267. +static struct timer_list motor_off_timer =
  4268. +                         { NULL, NULL, 0, 0, fd_motor_off_timer };
  4269. +#ifdef TRACKBUFFER
  4270. +static struct timer_list readtrack_timer =
  4271. +                         { NULL, NULL, 0, 0, fd_readtrack_check };
  4272. +#endif
  4273. +
  4274. +
  4275. +
  4276. +
  4277. +/* Select the side to use. */
  4278. +
  4279. +static void fd_select_side( int side )
  4280. +
  4281. +{    unsigned long flags;
  4282.  
  4283.    save_flags(flags);
  4284.    cli();
  4285.    
  4286. -  if(side==0)
  4287. -   {
  4288. -    sound_ym.rd_data_reg_sel=14; /* Select PSG Port A */
  4289. -    sound_ym.wd_data = sound_ym.rd_data_reg_sel | 0x01;
  4290. -   }
  4291. -  else
  4292. -   {
  4293. -    sound_ym.rd_data_reg_sel=14; /* Select PSG Port A */
  4294. -    sound_ym.wd_data = sound_ym.rd_data_reg_sel & 0xfe;
  4295. -   }
  4296. +    sound_ym.rd_data_reg_sel = 14; /* Select PSG Port A */
  4297. +    sound_ym.wd_data = (side == 0) ? sound_ym.rd_data_reg_sel | 0|01 :
  4298. +                                     sound_ym.rd_data_reg_sel & 0xfe;
  4299.  
  4300.     restore_flags(flags);
  4301.  }
  4302. -#endif
  4303.  
  4304.  
  4305. -#ifdef __notneeded__
  4306. -static struct timer_list motor_on_timer;
  4307. -static struct timer_list motor_off_timer[FD_MAX_UNITS];
  4308. -static int on_attempts;
  4309. -#endif
  4310. +/* Select a drive, update the FDC's track register and set the correct
  4311. + * clock speed for this disk's type.
  4312. + */
  4313. +
  4314. +static void fd_select_drive( int drive )
  4315.  
  4316. -static void fd_select (int drive, int side)
  4317.  {
  4318.    unsigned long flags;
  4319.    unsigned char tmp;
  4320.    
  4321. -  if (drive == selected)
  4322. +    if (drive == SelectedDrive)
  4323.        return;
  4324. -  selected = drive;
  4325.  
  4326.    save_flags(flags);
  4327.    cli();
  4328. -
  4329. -  if (side == 0)
  4330. -   {
  4331. -    sound_ym.rd_data_reg_sel=14;    /* Select PSG Port A */
  4332. +    sound_ym.rd_data_reg_sel = 14; /* Select PSG Port A */
  4333.      tmp = sound_ym.rd_data_reg_sel;
  4334. -    sound_ym.wd_data = (tmp & ~2) | 1;    /* Select Side 0 and Drive A */
  4335. -   }
  4336. -  else
  4337. -   {
  4338. +    sound_ym.wd_data = (tmp | DSKDRVNONE) & ~(drive == 0 ? DSKDRV0 : DSKDRV1);
  4339. +    restore_flags(flags);
  4340. +
  4341. +    /* restore track register to saved value */
  4342. +    FDC_WRITE( FDCREG_TRACK, unit[drive].track );
  4343. +    udelay(40);
  4344. +
  4345. +    /* select 8/16 MHz */
  4346. +    if (unit[drive].disktype)
  4347. +        dma_wd.fdc_speed = unit[drive].disktype->fdc_speed;
  4348. +    
  4349. +    SelectedDrive = drive;
  4350. +}
  4351. +
  4352. +
  4353. +/* Deselect both drives. */
  4354. +
  4355. +static void fd_deselect( void )
  4356. +
  4357. +{    unsigned long flags;
  4358. +
  4359. +    save_flags(flags);
  4360. +    cli();
  4361.      sound_ym.rd_data_reg_sel=14;    /* Select PSG Port A */
  4362. -    tmp = sound_ym.rd_data_reg_sel;
  4363. -    sound_ym.wd_data = tmp & ~3;    /* Select Side 1 and Drive A */
  4364. +    sound_ym.wd_data = sound_ym.rd_data_reg_sel | 7; /* no drives selected */
  4365. +    restore_flags(flags);
  4366. +
  4367. +    SelectedDrive = -1;
  4368. +}
  4369. +
  4370. +
  4371. +/* This timer function deselects the drives when the FDC switched the
  4372. + * motor off. The deselection cannot happen earlier because the FDC
  4373. + * counts the index signals, which arrive only if one drive is selected.
  4374. + */
  4375. +
  4376. +static void fd_motor_off_timer( unsigned long dummy )
  4377. +
  4378. +{    unsigned long flags;
  4379. +    unsigned char status;
  4380. +    int              delay;
  4381. +
  4382. +    del_timer( &motor_off_timer );
  4383. +    
  4384. +    if (SelectedDrive < 0)
  4385. +        /* no drive selected, needn't deselect anyone */
  4386. +        return;
  4387. +
  4388. +    save_flags(flags);
  4389. +    cli();
  4390. +    
  4391. +    if (stdma_islocked())
  4392. +        goto retry;
  4393. +
  4394. +    status = FDC_READ( FDCREG_STATUS );
  4395. +
  4396. +    if (!(status & 0x80)) {
  4397. +        /* motor already turned off by FDC -> deselect drives */
  4398. +        fd_deselect();
  4399. +        restore_flags(flags);
  4400. +        MotorOn = 0;
  4401. +        return;
  4402.     }
  4403. +    /* not yet off, try again */
  4404.  
  4405. +  retry:
  4406.    restore_flags(flags);
  4407. +    /* Test again later; if tested too often, it seems there is no disk
  4408. +     * in the drive and the FDC will leave the motor on forever (or,
  4409. +     * at least until a disk is inserted). So we'll test only twice
  4410. +     * per second from then on...
  4411. +     */
  4412. +    delay = (MotorOffTrys < FD_MOTOR_OFF_MAXTRY) ?
  4413. +                (++MotorOffTrys, HZ/20) : HZ/2;
  4414. +    START_MOTOR_OFF_TIMER( delay );
  4415.  }
  4416.  
  4417. -static void fd_deselect (int drive)
  4418. -{
  4419. +
  4420. +/* This function is repeatedly called to detect disk changes (as good
  4421. + * as possible) and keep track of the current state of the write protection.
  4422. + */
  4423. +
  4424. +static void check_change( void )
  4425. +
  4426. +{    static int    drive = 0;
  4427. +
  4428.    unsigned long flags;
  4429. +    unsigned char old_porta;
  4430. +    int              stat;
  4431.  
  4432. -  if (drive != selected)
  4433. -      return;
  4434. +    if (++drive > 1 || !unit[drive].connected)
  4435. +        drive = 0;
  4436. +
  4437. +    if (!stdma_islocked()) {
  4438.  
  4439.    save_flags(flags);
  4440.    cli();
  4441. -  sound_ym.rd_data_reg_sel=14; /* Select PSG Port A */
  4442. -  sound_ym.wd_data = sound_ym.rd_data_reg_sel | 7; /* no drives selected */
  4443. +        TEST_PAGE("check change timer",0);
  4444. +        sound_ym.rd_data_reg_sel = 14;
  4445. +        old_porta = sound_ym.rd_data_reg_sel;
  4446. +        sound_ym.wd_data = (old_porta | DSKDRVNONE) &
  4447. +                           ~(drive == 0 ? DSKDRV0 : DSKDRV1);
  4448. +        stat = !!(FDC_READ( FDCREG_STATUS ) & FDCSTAT_WPROT);
  4449. +        sound_ym.wd_data = old_porta;
  4450.    restore_flags(flags);
  4451.  
  4452. -  selected=-1;
  4453. +        if (stat != unit[drive].wpstat) {
  4454. +            DPRINT(( "wpstat[%d] = %d\n", drive, stat ));
  4455. +            unit[drive].wpstat = stat;
  4456. +            set_bit (drive, &changed_floppies);
  4457. +        }
  4458. +    }
  4459. +    
  4460. +    START_CHECK_CHANGE_TIMER( CHECK_CHANGE_DELAY );
  4461.  }
  4462.  
  4463. -static void fd_nobusy(void)
  4464. -{
  4465. - unsigned char fd_status;
  4466.   
  4467. - do
  4468. -   fd_status = mfp.par_dt_reg & 0x20;
  4469. - while(fd_status != 0);
  4470. +/* Handling of the Head Settling Flag: This flag should be set after each
  4471. + * seek operation, because we dont't use seeks with verify.
  4472. + */
  4473.  
  4474. +static __inline__ void set_head_settle_flag( void )
  4475. +
  4476. +{
  4477. +    HeadSettleFlag = FDCCMDADD_E;
  4478.  }
  4479.  
  4480. -/*======================================================================
  4481. -  Seek the drive to track 0.
  4482. -  The drive must be active and the motor must be running.
  4483. -  Returns standard floppy error code.
  4484. -======================================================================*/
  4485. -#ifdef __notneeded__
  4486. -static int fd_calibrate(int drive)
  4487. +static __inline__ int get_head_settle_flag( void )
  4488. +
  4489.  {
  4490. +    int    tmp = HeadSettleFlag;
  4491. +    HeadSettleFlag = 0;
  4492. +    return( tmp );
  4493. +}
  4494.  
  4495. -  fd_select(drive,0);
  4496. -  dma_wd.dma_mode_status=FDCSELREG_STP;
  4497. -  dma_wd.fdc_acces_seccount=FDCCMD_RESTORE | FDCCMDADD_V ;
  4498.    
  4499. -  fd_nobusy();
  4500. -  fd_deselect(drive);
  4501.    
  4502. -    return 1;
  4503. +
  4504. +/* General Interrupt Handling */
  4505. +
  4506. +static void (*FloppyIRQHandler)( int status ) = NULL;
  4507. +
  4508. +static void floppy_irq( struct intframe *fp, void *data )
  4509. +
  4510. +{
  4511. +    unsigned char status;
  4512. +    void (*handler)( int );
  4513. +
  4514. +    handler = FloppyIRQHandler;
  4515. +    FloppyIRQHandler = NULL;
  4516. +
  4517. +    if (handler) {
  4518. +        nop();
  4519. +        status = FDC_READ( FDCREG_STATUS );
  4520. +        DPRINT(("FDC irq, status = %02x handler = %08lx\n",status,(unsigned long)handler));
  4521. +        udelay(40);
  4522. +        handler( status );
  4523. +    }
  4524. +    else {
  4525. +        DPRINT(("FDC irq, no handler\n"));
  4526. +    }
  4527.  }
  4528. +
  4529. +#define    SET_IRQ_HANDLER(proc) do { FloppyIRQHandler = (proc); } while(0)
  4530. +
  4531. +
  4532. +/* do_fd_action() is the general procedure for a fd request: All
  4533. + * required parameter settings (drive select, side select, track
  4534. + * position) are checked and set if needed. For each of these
  4535. + * parameters and the actual reading or writing exist two functions:
  4536. + * one that starts the setting (or skips it if possible) and one
  4537. + * callback for the "done" interrupt. Each done func calls the next
  4538. + * set function to propagate the request down to fd_rwsec_done().
  4539. + */
  4540. +
  4541. +static void do_fd_action( int drive )
  4542. +
  4543. +{
  4544. +    TEST_PAGE("do_fd_action",drive);
  4545. +    DPRINT(("do_fd_action\n"));
  4546. +    
  4547. +#ifdef TRACKBUFFER
  4548. +  repeat:
  4549. +
  4550. +    if (IS_BUFFERED( drive, ReqSide, ReqTrack )) {
  4551. +        if (ReqCmd == READ) {
  4552. +            copy_buffer( SECTOR_BUFFER(ReqSector), ReqData );
  4553. +            if (++ReqCnt < 2) {
  4554. +                /* read next sector */
  4555. +                setup_req_params( drive );
  4556. +                goto repeat;
  4557. +            }
  4558. +            else {
  4559. +                /* all sectors finished */
  4560. +                end_request( 1 );
  4561. +                redo_fd_request();
  4562. +                return;
  4563. +            }
  4564. +        }
  4565. +        else {
  4566. +            /* cmd == WRITE, pay attention to track buffer
  4567. +             * consistency! */
  4568. +            copy_buffer( ReqData, SECTOR_BUFFER(ReqSector) );
  4569. +        }
  4570. +    }
  4571.  #endif
  4572.  
  4573. -/*======================================================================
  4574. -  Seek the drive to the requested cylinder.
  4575. -  The drive must have been calibrated at some point before this.
  4576. -  The drive must also be active and the motor must be running.
  4577. -======================================================================*/
  4578. -static int fd_seek(unsigned short drive, unsigned short track)
  4579. -{
  4580. -  dma_wd.dma_mode_status=FDCSELREG_DTA;
  4581. -  nop();
  4582. -  dma_wd.fdc_acces_seccount=track;
  4583. -  udelay (1);
  4584. -  dma_wd.dma_mode_status=FDCSELREG_STP;
  4585. -  nop();
  4586. -  dma_wd.fdc_acces_seccount=FDCCMD_SEEK | FDCCMDADD_V ;
  4587. -  udelay (1);
  4588. -  fd_nobusy();
  4589. +    if (SelectedDrive != drive)
  4590. +        fd_select_drive( drive );
  4591.      
  4592. -    return 1;
  4593. +    if (unit[drive].track == -1)
  4594. +        fd_calibrate();
  4595. +    else if (unit[drive].track != ReqTrack << unit[drive].disktype->stretch)
  4596. +        fd_seek();
  4597. +    else
  4598. +        fd_rwsec();
  4599.  }
  4600.  
  4601.  
  4602. -struct header {
  4603. -    unsigned char magic;
  4604. -    unsigned char track;
  4605. -    unsigned char sect;
  4606. -    unsigned char ord;
  4607. -    unsigned char labels[16];
  4608. -    unsigned long hdrchk;
  4609. -    unsigned long datachk;
  4610. -};
  4611. +/* Seek to track 0 if the current track is unknown */
  4612. +
  4613. +static void fd_calibrate( void )
  4614. +
  4615. +{
  4616. +    TEST_PAGE("fd_calibrate",0);
  4617. +    if (unit[SelectedDrive].track >= 0) {
  4618. +        fd_calibrate_done( 0 );
  4619. +        return;
  4620. +    }
  4621. +
  4622. +    dma_wd.fdc_speed = 0;     /* always seek with 8 Mhz */;
  4623. +    DPRINT(("fd_calibrate\n"));
  4624. +    SET_IRQ_HANDLER( fd_calibrate_done );
  4625. +    /* we can't verify, since the speed may be incorrect */
  4626. +    FDC_WRITE( FDCREG_CMD, FDCCMD_RESTORE | unit[SelectedDrive].steprate );
  4627. +
  4628. +    NeedSeek = 1;
  4629. +    MotorOn = 1;
  4630. +    /* wait for IRQ */
  4631. +}
  4632.  
  4633.  
  4634. +static void fd_calibrate_done( int status )
  4635.  
  4636. -/*==========================================================================
  4637. -  atari_write converts track/labels data to raw track data
  4638. -==========================================================================*/
  4639. -static void atari_write(int dr, unsigned short tr, unsigned short sec)
  4640.  {
  4641. -  unsigned long phys_secbuf,flags;
  4642. +    TEST_PAGE("calibrate_done",0);
  4643. +    DPRINT(("fd_calibrate_done()\n"));
  4644.      
  4645. -  sec=sec+1;
  4646. +    /* set the correct speed now */
  4647. +    dma_wd.fdc_speed = unit[SelectedDrive].disktype->fdc_speed;
  4648. +    if (status & FDCSTAT_RECNF) {
  4649. +        printk( "fd%d: restore failed\n", SelectedDrive );
  4650. +        end_request( 0 );
  4651. +        redo_fd_request();
  4652. +    }
  4653. +    else {
  4654. +        unit[SelectedDrive].track = 0;
  4655. +        fd_seek();
  4656. +    }
  4657. +}
  4658.    
  4659. -  phys_secbuf = (unsigned long) trackdata;
  4660.    
  4661. -  save_flags(flags);  
  4662. -  cli();
  4663. +/* Seek the drive to the requested track. The drive must have been
  4664. + * calibrated at some point before this.
  4665. + */
  4666.    
  4667. -  fd_select (dr, tr & 1);
  4668. +static void fd_seek( void )
  4669.    
  4670. -  tr=tr/2;
  4671. +{
  4672. +    TEST_PAGE("fd_seek",0);
  4673. +    if (unit[SelectedDrive].track == ReqTrack << 
  4674. +        unit[SelectedDrive].disktype->stretch) {
  4675. +        fd_seek_done( 0 );
  4676. +        return;
  4677. +    }
  4678.  
  4679. -  /* Setup head pos. */
  4680. -  fd_seek(dr,tr);
  4681. +     dma_wd.fdc_speed = 0;    /* always seek witch 8 Mhz */
  4682.  
  4683. +    DPRINT(("fd_seek() to track %d\n",ReqTrack));
  4684. +    FDC_WRITE( FDCREG_DATA, ReqTrack << 
  4685. +        unit[SelectedDrive].disktype->stretch);
  4686. +    udelay(40);
  4687. +    SET_IRQ_HANDLER( fd_seek_done );
  4688. +    FDC_WRITE( FDCREG_CMD, FDCCMD_SEEK | unit[SelectedDrive].steprate );
  4689. +
  4690. +    MotorOn = 1;
  4691. +    set_head_settle_flag();
  4692. +    /* wait for IRQ */
  4693. +}
  4694.  
  4695. -  /* Setup DMA */
  4696. -  dma_wd.dma_lo=(unsigned char)phys_secbuf;
  4697. -  phys_secbuf = phys_secbuf >> 8;
  4698. -  dma_wd.dma_md=(unsigned char)phys_secbuf;
  4699. -  phys_secbuf = phys_secbuf >> 8;
  4700. -  dma_wd.dma_hi=(unsigned char)phys_secbuf;
  4701.    
  4702. +static void fd_seek_done( int status )
  4703.  
  4704. -  /* Clear FIFO and switch DMA to read-mode ! */  
  4705. -  dma_wd.dma_mode_status=0x190;  
  4706. -  dma_wd.dma_mode_status=0x90;  
  4707. -  dma_wd.dma_mode_status=0x190;  
  4708. +{
  4709. +    TEST_PAGE("fd_seek_done",0);
  4710. +    DPRINT(("fd_seek_done()\n"));
  4711. +    /* set the correct speed */
  4712. +     dma_wd.fdc_speed = unit[SelectedDrive].disktype->fdc_speed;    
  4713. +    if (status & FDCSTAT_RECNF) {
  4714. +        printk( "fd%d: seek error\n", SelectedDrive );
  4715. +        /* we don't know exactly which track we are on now! */
  4716. +        unit[SelectedDrive].track = -1;
  4717. +        end_request( 0 );
  4718. +        redo_fd_request();
  4719. +    }
  4720. +    else {
  4721. +        unit[SelectedDrive].track = ReqTrack << 
  4722. +            unit[SelectedDrive].disktype->stretch;
  4723. +        NeedSeek = 0;
  4724. +        fd_rwsec();
  4725. +    }
  4726. +}
  4727.  
  4728. -  /* Transmit only 1 Sector */
  4729. -  dma_wd.fdc_acces_seccount=0x01;
  4730. -  udelay (1);  
  4731.    
  4732. +/* This does the actual reading/writing after positioning the head
  4733. + * over the correct track.
  4734. + */
  4735. +
  4736. +#ifdef TRACKBUFFER
  4737. +static int MultReadInProgress = 0;
  4738. +#endif
  4739.    
  4740. -  dma_wd.dma_mode_status=FDCSELREG_SEC | 0x100 ;
  4741. +
  4742. +static void fd_rwsec( void )
  4743. +    
  4744. +{
  4745. +    unsigned long paddr, flags;
  4746. +    unsigned int  rwflag, old_motoron;
  4747. +    unsigned int track;
  4748. +#ifdef TRACKBUFFER
  4749. +    int    single_read = 0;
  4750. +#endif
  4751. +    
  4752. +    TEST_PAGE("fd_rwsec",0);
  4753. +    DPRINT(("fd_rwsec(), Sec=%d, Access=%c\n",ReqSector, ReqCmd == WRITE ? 'w' : 'r' ));
  4754. +    if (ReqCmd == WRITE) {
  4755. +        copy_buffer( ReqData, DMABuffer );
  4756. +        cache_push( PhysDMABuffer, 512 );
  4757. +        paddr = PhysDMABuffer;
  4758. +        rwflag = 0x100;
  4759. +    }
  4760. +    else {
  4761. +#ifdef TRACKBUFFER
  4762. +        paddr = PhysTrackBuffer;
  4763. +        if (error_drive == SelectedDrive && error_track == ReqTrack
  4764. +            && error_side == ReqSide)
  4765. +          {
  4766. +            DPRINT (("fd_rwsec: single sector read after error\n"));
  4767. +            single_read = 1;
  4768. +            paddr = PhysDMABuffer;
  4769. +          }
  4770. +#else
  4771. +        paddr = PhysDMABuffer;
  4772. +#endif
  4773. +        rwflag = 0;
  4774. +    }
  4775. +
  4776. +    fd_select_side( ReqSide );
  4777. +  
  4778. +    /* Start sector of this operation */
  4779. +#ifdef TRACKBUFFER
  4780. +    FDC_WRITE( FDCREG_SECTOR, rwflag || single_read ? ReqSector : 1 );
  4781. +#else
  4782. +    FDC_WRITE( FDCREG_SECTOR, ReqSector );
  4783. +#endif
  4784. +    /* Cheat for track if stretch != 0 */
  4785. +    if (unit[SelectedDrive].disktype->stretch) {
  4786. +        track = FDC_READ( FDCREG_TRACK);
  4787. +        FDC_WRITE( FDCREG_TRACK, track >> 
  4788. +            unit[SelectedDrive].disktype->stretch);
  4789. +    }
  4790. +    udelay(40);
  4791. +  
  4792. +    /* Setup DMA */
  4793. +    TEST_PAGE("before setting DMA",paddr);
  4794. +    save_flags(flags);  
  4795. +    cli();
  4796. +    dma_wd.dma_lo = (unsigned char)paddr;
  4797. +    paddr >>= 8;
  4798. +    nop();
  4799. +    dma_wd.dma_md = (unsigned char)paddr;
  4800. +    paddr >>= 8;
  4801.    nop();
  4802. -  dma_wd.fdc_acces_seccount=sec;   
  4803. -  udelay (1);
  4804. +    dma_wd.dma_hi = (unsigned char)paddr;
  4805. +    nop();
  4806. +    restore_flags(flags);
  4807. +    TEST_PAGE("after setting DMA",ReqTrack*2+ReqSide);
  4808.    
  4809. -  /* Start Write */
  4810. -  dma_wd.dma_mode_status=FDCSELREG_STP | 0x100 ;
  4811. +    /* Clear FIFO and switch DMA to correct mode */  
  4812. +    dma_wd.dma_mode_status = 0x90 | rwflag;  
  4813. +    nop();
  4814. +    dma_wd.dma_mode_status = 0x90 | (rwflag ^ 0x100);  
  4815. +    nop();
  4816. +    dma_wd.dma_mode_status = 0x90 | rwflag;
  4817.    nop();
  4818. -  dma_wd.fdc_acces_seccount=FDCCMD_WRSEC ;
  4819. -  udelay (1);
  4820.    
  4821. -  fd_nobusy();  /* Wait for IRQ 5 */
  4822. +    /* How many sectors for DMA */
  4823. +#ifdef TRACKBUFFER
  4824. +    dma_wd.fdc_acces_seccount =
  4825. +        rwflag || single_read ? 1 : unit[SelectedDrive].disktype->spt;
  4826. +#else
  4827. +    dma_wd.fdc_acces_seccount = 1;
  4828. +#endif
  4829.    
  4830. -  restore_flags(flags);
  4831. +    udelay(40);  
  4832.    
  4833. -  fd_deselect(dr);
  4834. +    /* Start operation */
  4835. +    dma_wd.dma_mode_status = FDCSELREG_STP | rwflag;
  4836. +    udelay(40);
  4837. +    SET_IRQ_HANDLER( fd_rwsec_done );
  4838. +    dma_wd.fdc_acces_seccount =
  4839. +        (rwflag ? (FDCCMD_WRSEC | FDCCMDADD_P) :
  4840. +#ifdef TRACKBUFFER
  4841. +                  (FDCCMD_RDSEC | (single_read ? 0 : FDCCMDADD_M))
  4842. +#else
  4843. +                  FDCCMD_RDSEC
  4844. +#endif                      
  4845. +         ) | get_head_settle_flag();
  4846.  
  4847. -  udelay (10);
  4848. +    old_motoron = MotorOn;
  4849. +    MotorOn = 1;
  4850. +    NeedSeek = 1;
  4851. +    /* wait for interrupt */
  4852. +
  4853. +#ifdef TRACKBUFFER
  4854. +    if (!rwflag && !single_read) {
  4855. +        /* If reading a whole track, wait about one disk rotation and
  4856. +         * then check if all sectors are read. The FDC will even
  4857. +         * search for the first non-existant sector and need 1 sec to
  4858. +         * recognise that it isn't present :-(
  4859. +         */
  4860. +        readtrack_timer.expires = HZ/5 + 3*HZ/50 + (old_motoron ? 0 : HZ);
  4861. +                                  /* 1 rot. + 5 rot.s if motor was off  */
  4862. +        add_timer( &readtrack_timer );
  4863. +        MultReadInProgress = 1;
  4864.   }
  4865. +#endif
  4866. +    TEST_PAGE("leaving rwsec",0);
  4867. +}
  4868.  
  4869. -/*==========================================================================
  4870. -  atari_read reads a raw track of data into a track buffer
  4871. -==========================================================================*/
  4872. -static int atari_read(int dr, unsigned short tr, unsigned short sec)
  4873. -{
  4874. -  unsigned long phys_secbuf,flags;
  4875.      
  4876. -  phys_secbuf = (unsigned long) trackdata;
  4877. +#ifdef TRACKBUFFER
  4878.    
  4879. -  sec=sec+1;
  4880. +static void fd_readtrack_check( unsigned long dummy )
  4881. +  
  4882. +{    unsigned long flags, addr;
  4883.    
  4884.    save_flags(flags);  
  4885.    cli();
  4886.    
  4887. -  fd_select (dr, tr & 1);
  4888. +    TEST_PAGE("check timer",0);
  4889. +    del_timer( &readtrack_timer );
  4890.    
  4891. -  tr=tr/2;
  4892. +    if (!MultReadInProgress) {
  4893. +        /* This prevents a race condition that could arise if the
  4894. +         * interrupt is triggered while the calling of this timer
  4895. +         * callback function takes place. The IRQ function then has
  4896. +         * already cleared 'MultReadInProgress'  when control flow
  4897. +         * gets here.
  4898. +         */
  4899. +        restore_flags(flags);
  4900. +        return;
  4901. +    }
  4902.    
  4903. -  /* Setup head pos. */
  4904. -  fd_seek(dr,tr);
  4905. +    /* get the current DMA address */
  4906. +    addr = dma_wd.dma_lo & 0xff;
  4907. +    nop();
  4908. +    addr |= (dma_wd.dma_md & 0xff) << 8;
  4909. +    nop();
  4910. +    addr |= (dma_wd.dma_hi & 0xff) << 16;
  4911. +    nop();
  4912.    
  4913. +    if (addr >= PhysTrackBuffer + unit[SelectedDrive].disktype->spt*512) {
  4914. +        /* already read enough data, force an FDC interrupt to stop
  4915. +         * the read operation
  4916. +         */
  4917. +        SET_IRQ_HANDLER( NULL );
  4918. +        restore_flags(flags);
  4919. +        DPRINT(("fd_readtrack_check(): done\n"));
  4920. +        FDC_WRITE( FDCREG_CMD, FDCCMD_FORCI );
  4921. +        TEST_PAGE("Int force",0);
  4922. +        udelay(40);
  4923.  
  4924. -  /* Setup DMA */
  4925. -  dma_wd.dma_lo=(unsigned char)phys_secbuf;
  4926. -  phys_secbuf = phys_secbuf >> 8;
  4927. -  dma_wd.dma_md=(unsigned char)phys_secbuf;
  4928. -  phys_secbuf = phys_secbuf >> 8;
  4929. -  dma_wd.dma_hi=(unsigned char)phys_secbuf;
  4930. +        /* No error until now -- the FDC would have interrupted
  4931. +         * otherwise!
  4932. +         */
  4933. +        fd_rwsec_done( 0 );
  4934. +    }
  4935. +    else {
  4936. +        /* not yet finished, wait another tenth rotation */
  4937. +        restore_flags(flags);
  4938. +        DPRINT(("fd_readtrack_check(): not yet finished\n"));
  4939. +        readtrack_timer.expires = HZ/5/10;
  4940. +        add_timer( &readtrack_timer );
  4941. +    }
  4942. +}
  4943.    
  4944. +#endif
  4945.  
  4946. -  /* Clear FIFO and switch DMA to read-mode ! */  
  4947. -  dma_wd.dma_mode_status=0x90;  
  4948. -  dma_wd.dma_mode_status=0x190;  
  4949. -  dma_wd.dma_mode_status=0x90;  
  4950. -  /* Transmit only 1 Sector */
  4951. -  dma_wd.fdc_acces_seccount=0x01;
  4952. -  udelay (1);
  4953. +static void fd_rwsec_done( int status )
  4954.    
  4955. -  dma_wd.dma_mode_status=FDCSELREG_SEC;
  4956. -  nop();
  4957. -  dma_wd.fdc_acces_seccount=sec;   
  4958. -  udelay (1);
  4959. +{
  4960. +    unsigned int track;
  4961. +#ifdef TRACKBUFFER
  4962. +    int single_read = MultReadInProgress == -1;
  4963. +#endif
  4964. +
  4965. +    TEST_PAGE("rwsec_done",ReqTrack*2+ReqSide);
  4966. +    DPRINT(("fd_rwsec_done()\n"));
  4967. +
  4968. +#ifdef TRACKBUFFER
  4969. +    if (ReqCmd == READ && !MultReadInProgress) return;
  4970. +    MultReadInProgress = 0;
  4971.    
  4972. -  /* Start READ */
  4973. -  dma_wd.dma_mode_status=FDCSELREG_STP;
  4974. +    if (ReqCmd == READ && !single_read)
  4975. +        del_timer( &readtrack_timer );
  4976. +#endif
  4977. +
  4978. +    /* Correct the track if stretch != 0 */
  4979. +    if (unit[SelectedDrive].disktype->stretch) {
  4980. +        track = FDC_READ( FDCREG_TRACK);
  4981. +        FDC_WRITE( FDCREG_TRACK, track << 
  4982. +            unit[SelectedDrive].disktype->stretch);
  4983. +    }
  4984. +
  4985. +#ifndef TRACKBUFFER
  4986. +    dma_wd.dma_mode_status = 0x90;
  4987.    nop();
  4988. -  dma_wd.fdc_acces_seccount=FDCCMD_RDSEC ;
  4989. -  udelay (1);
  4990. +    if (!(dma_wd.dma_mode_status & 0x01)) {
  4991. +        printk( "fd%d: DMA error\n", SelectedDrive );
  4992. +        goto err_end;
  4993. +    }
  4994. +#endif
  4995.      
  4996. -  fd_nobusy();  /* Wait for IRQ 5 */
  4997. +    if (ReqCmd == WRITE && (status & FDCSTAT_WPROT)) {
  4998. +        printk( "fd%d: is write protected\n", SelectedDrive );
  4999. +        goto err_end;
  5000. +    }    
  5001. +    if ((status & FDCSTAT_RECNF)
  5002. +#ifdef TRACKBUFFER
  5003. +        /* RECNF is no error after a multiple read when the FDC
  5004. +         * searched for a non-existant sector!
  5005. +         */
  5006. +        && !(ReqCmd == READ && !single_read &&
  5007. +             FDC_READ(FDCREG_SECTOR) > unit[SelectedDrive].disktype->spt)
  5008. +#endif
  5009. +       ) {
  5010. +        if (Probing) {
  5011. +            if (unit[SelectedDrive].disktype > disk_type) {
  5012. +                /* try another disk type */
  5013. +                unit[SelectedDrive].disktype--;
  5014. +            }
  5015. +            else
  5016. +                Probing=0;
  5017. +        } else {    
  5018. +/* record not found, but not probing. Maybe stretch wrong ? Restart probing */
  5019. +            if (unit[SelectedDrive].autoprobe) {
  5020. +                unit[SelectedDrive].disktype = disk_type + NUM_DISK_TYPES-1;
  5021. +                Probing = 1;
  5022. +            }
  5023. +        }
  5024. +        if (Probing) {
  5025. +            dma_wd.fdc_speed = unit[SelectedDrive].disktype->fdc_speed;
  5026. +            setup_req_params( SelectedDrive );
  5027. +#ifdef TRACKBUFFER
  5028. +            BufferDrive = -1;
  5029. +#endif
  5030. +            do_fd_action( SelectedDrive );
  5031. +            return;
  5032. +        }
  5033.    
  5034. -  restore_flags(flags);
  5035. +        printk( "fd%d: sector %d not found\n", SelectedDrive,
  5036. +                FDC_READ (FDCREG_SECTOR) );
  5037. +        goto err_end;
  5038. +    }
  5039. +    if (status & FDCSTAT_CRC) {
  5040. +        printk( "fd%d: CRC error\n", SelectedDrive );
  5041. +        goto err_end;
  5042. +    }
  5043. +    if (status & FDCSTAT_LOST) {
  5044. +        printk( "fd%d: lost data\n", SelectedDrive );
  5045. +        goto err_end;
  5046. +    }
  5047.    
  5048. -  fd_deselect(dr);
  5049. +    Probing = 0;
  5050.    
  5051. -    return 0;
  5052. +    if (ReqCmd == READ) {
  5053. +#ifdef TRACKBUFFER
  5054. +        if (single_read)
  5055. +          {
  5056. +            cache_clear (PhysDMABuffer, 512);
  5057. +            copy_buffer (DMABuffer, ReqData);
  5058. +          }
  5059. +        else
  5060. +          {
  5061. +            cache_clear (PhysTrackBuffer, MAX_SECTORS * 512);
  5062. +            BufferDrive = SelectedDrive;
  5063. +            BufferSide  = ReqSide;
  5064. +            BufferTrack = ReqTrack;
  5065. +            copy_buffer (SECTOR_BUFFER (ReqSector), ReqData);
  5066. +          }
  5067. +#else
  5068. +        cache_clear( PhysDMABuffer, 512 );
  5069. +        copy_buffer( DMABuffer, ReqData );
  5070. +#endif
  5071. +    }
  5072. +  
  5073. +    if (++ReqCnt < 2) {
  5074. +        /* read next sector */
  5075. +        setup_req_params( SelectedDrive );
  5076. +        do_fd_action( SelectedDrive );
  5077. +    }
  5078. +    else {
  5079. +        /* all sectors finished */
  5080. +        end_request( 1 );
  5081. +        redo_fd_request();
  5082. +    }
  5083. +    return;
  5084. +  
  5085. +  err_end:
  5086. +#ifdef TRACKBUFFER
  5087. +    BufferDrive = -1;
  5088. +    if (ReqCmd == READ && !single_read)
  5089. +      {
  5090. +        FDC_WRITE (FDCREG_CMD, FDCCMD_FORCI);
  5091. +        udelay (40);
  5092. +        error_drive = SelectedDrive;
  5093. +        error_track = ReqTrack;
  5094. +        error_side = ReqSide;
  5095. +        setup_req_params (SelectedDrive);
  5096. +        do_fd_action (SelectedDrive);
  5097. +        return;
  5098. +      }
  5099. +#endif
  5100. +    end_request( 0 );
  5101. +    redo_fd_request();
  5102.  }
  5103.  
  5104. +
  5105. +/* The (noop) seek operation here is needed to make the WP bit in the
  5106. + * FDC status register accessible for check_change. If the last disk
  5107. + * operation would have been a RDSEC, this bit would always read as 0
  5108. + * no matter what :-( To save time, the seek goes to the track we're
  5109. + * already on.
  5110. + */
  5111. +
  5112. +static void finish_fdc( void )
  5113. +
  5114. +{    unsigned long flags;
  5115. +
  5116. +    TEST_PAGE("finish_fdc",0);
  5117. +
  5118. +    if (NeedSeek)
  5119. +      {
  5120. +        FDC_WRITE (FDCREG_DATA, unit[SelectedDrive].track);
  5121. +        SET_IRQ_HANDLER (NULL);
  5122. +        FDC_WRITE (FDCREG_CMD, FDCCMD_SEEK);
  5123. +
  5124. +        MotorOn = 1;
  5125. +        /* don't wait for IRQ, just go on */
  5126. +      }
  5127. +
  5128. +    if ((timer_active & (1 << FLOPPY_TIMER)) &&
  5129. +        timer_table[FLOPPY_TIMER].expires < jiffies + 5)
  5130. +        /* If the check for a disk change is done too early after this
  5131. +         * last seek command, the WP bit still reads wrong :-((
  5132. +         */
  5133. +        timer_table[FLOPPY_TIMER].expires = jiffies + 5;
  5134. +    else
  5135. +        START_CHECK_CHANGE_TIMER( CHECK_CHANGE_DELAY );
  5136. +    del_timer( &motor_off_timer );
  5137. +    START_MOTOR_OFF_TIMER( FD_MOTOR_OFF_DELAY );
  5138. +
  5139. +    save_flags(flags);
  5140. +    cli();
  5141. +    stdma_release();
  5142. +    fdc_busy = 0;
  5143. +    wake_up( &fdc_wait );
  5144. +    restore_flags(flags);
  5145. +
  5146. +    DPRINT(("finish_fdc() finished\n"));
  5147. +    TEST_PAGE("end of finish_fdc",0);
  5148. +}
  5149. +
  5150. +
  5151.  /*
  5152.   * Note that MAX_ERRORS=X doesn't imply that we retry every bad read
  5153.   * max X times - some types of errors increase the errorcount by 2 or
  5154. @@ -372,13 +1003,6 @@
  5155.   */
  5156.  #define MAX_ERRORS 12
  5157.  
  5158. -/*
  5159. - * The driver is trying to determine the correct media format
  5160. - * while probing is set. rw_interrupt() clears it after a
  5161. - * successful access.
  5162. - */
  5163. -static int probing = 0;
  5164. -
  5165.  /* Prevent "aliased" accesses. */
  5166.  static fd_ref[4] = { 0,0,0,0 };
  5167.  static fd_device[4] = { 0,0,0,0 };
  5168. @@ -392,50 +1016,114 @@
  5169.  /* Current error count. */
  5170.  #define CURRENT_ERRORS (CURRENT->errors)
  5171.  
  5172. -static void floppy_off (unsigned int nr)
  5173. -{
  5174. -}
  5175.  
  5176. +/* dummy for blk.h */
  5177. +static void floppy_off( unsigned int nr) {}
  5178.  
  5179.  
  5180. -/*
  5181. - * floppy-change is never called from an interrupt, so we can relax a bit
  5182. - * here, sleep etc. Note that floppy-on tries to set current_DOR to point
  5183. - * to the desired drive, but it will probably not survive the sleep if
  5184. - * several floppies are used at the same time: thus the loop.
  5185. +/* The detection of disk changes is a dark chapter in Atari history :-(
  5186. + * Because the "Drive ready" signal isn't present in the Atari
  5187. + * hardware, one has to rely on the "Write Protect". This works fine,
  5188. + * as long as no write protected disks are used. TOS solves this
  5189. + * problem by introducing tri-state logic ("maybe changed") and
  5190. + * looking at the serial number in block 0. This isn't possible for
  5191. + * Linux, since the floppy driver can't make assumptions about the
  5192. + * filesystem used on the disk and thus the contents of block 0. I've
  5193. + * choosen the method to always say "The disk was changed" if it is
  5194. + * unsure whether it was. This implies that every open or mount
  5195. + * invalidates the disk buffers if you work with write protected
  5196. + * disks. But at least this is better than working with incorrect data
  5197. + * due to unrecognised disk changes.
  5198.   */
  5199. -int atari_floppy_change(struct buffer_head * bh)
  5200. -{
  5201. +
  5202. +int atari_floppy_change( struct buffer_head * bh )
  5203. +
  5204. +{    unsigned int drive = (bh->b_dev & 0x03);
  5205. +
  5206. +    if (MAJOR(bh->b_dev) != MAJOR_NR) {
  5207. +        printk("floppy_changed: not a floppy\n");
  5208. +        return 0;
  5209. +    }
  5210. +    
  5211. +    if (test_bit (drive, &fake_change)) {
  5212. +        /* simulated change (e.g. after formatting) */
  5213. +        clear_bit (drive, &fake_change);
  5214. +        goto is_changed;
  5215. +    }
  5216. +    if (test_bit (drive, &changed_floppies)) {
  5217. +        /* surely changed (the WP signal changed at least once) */
  5218. +      is_changed:
  5219. +        clear_bit (drive, &changed_floppies);
  5220. +        goto ret_changed;
  5221. +    }
  5222. +    if (unit[drive].wpstat) {
  5223. +        /* WP is on -> could be changed: to be sure, buffers should be
  5224. +         * invalidated...
  5225. +         */
  5226. +      ret_changed:
  5227. +#ifdef TRACKBUFFER
  5228. +        BufferDrive = -1;
  5229. +        error_drive = -1;
  5230. +#endif
  5231. +        
  5232. +        unit[drive].disktype = NULL;
  5233. +        return 1;
  5234. +    }
  5235. +
  5236. +    /* It doesn't make sense to read or write block 0 (described by
  5237. +     * bh) here, because it doesn't answer our question :-(
  5238. +     */
  5239. +
  5240.      return 0;
  5241.  }
  5242.  
  5243. +
  5244.  static __inline__ void copy_buffer(void *from, void *to)
  5245. -{
  5246. -  ulong *p1,*p2;
  5247. -  int cnt;
  5248.  
  5249. -  p1 = (ulong *)from;
  5250. -  p2 = (ulong *)to;
  5251. +{    ulong    *p1 = (ulong *)from, *p2 = (ulong *)to;
  5252. +    int        cnt;
  5253.  
  5254. -  for (cnt = 0; cnt < 512/4; cnt++)
  5255. +    for( cnt = 512/4; cnt; cnt-- )
  5256.      *p2++ = *p1++;
  5257.  }
  5258.  
  5259.  
  5260. +/* This sets up the global variables describing the current request. */
  5261. +
  5262. +static void setup_req_params( int drive )
  5263. +
  5264. +{    int block = ReqBlock + ReqCnt;
  5265. +
  5266. +    ReqTrack = block / unit[drive].disktype->spt;
  5267. +    ReqSector = block - ReqTrack * unit[drive].disktype->spt + 1;
  5268. +    ReqSide = ReqTrack & 1;
  5269. +    ReqTrack >>= 1;
  5270. +    ReqData = ReqBuffer + 512 * ReqCnt;
  5271. +
  5272. +#ifdef TRACKBUFFER
  5273. +    if (error_drive == drive
  5274. +        && (error_track != ReqTrack || error_side != ReqSide))
  5275. +      error_drive = -1;
  5276. +#endif
  5277. +
  5278. +    DPRINT(("Request params: Si=%d Tr=%d Se=%d Data=%08lx\n",ReqSide, ReqTrack, ReqSector, ReqData ));
  5279. +}
  5280. +
  5281. +
  5282.  static void redo_fd_request(void)
  5283. +
  5284.  {
  5285. -    unsigned int block, track, sector;
  5286. -    int device, drive, cnt;
  5287. -    struct floppy_struct *floppy;
  5288. -    char *data;
  5289. +    int device, drive, type;
  5290. +    struct atari_floppy_struct *floppy;
  5291.  
  5292. +    TEST_PAGE("redo_fd_request",0);
  5293. +    if (CURRENT && CURRENT->dev < 0)
  5294. +        goto the_end;
  5295.    
  5296. -    if (CURRENT && CURRENT->dev < 0) return;
  5297. +repeat:
  5298.  
  5299. -    repeat:
  5300. -    
  5301. -  if(!CURRENT)
  5302. -    return;
  5303. +    if (!CURRENT)
  5304. +        goto the_end;
  5305.  
  5306.      if (MAJOR(CURRENT->dev) != MAJOR_NR)
  5307.          panic(DEVICE_NAME ": request list destroyed");
  5308. @@ -445,59 +1133,74 @@
  5309.              panic(DEVICE_NAME ": block not locked");
  5310.      }
  5311.  
  5312. -    probing = 0;
  5313.      device = MINOR(CURRENT_DEVICE);
  5314. +    drive = device & 3;
  5315. +    type = device >> 2;
  5316. +    floppy = &unit[drive];
  5317. +    
  5318. +    if (!floppy->connected) {
  5319. +        /* drive not connected */
  5320. +        printk( "Unknown Device: fd%d\n", drive );
  5321. +        end_request(0);
  5322. +        goto repeat;
  5323. +    }
  5324.          
  5325. -    if (CURRENT_DEVICE == 0x200 ) {
  5326. -        /* manual selection */
  5327. -        drive = 0;
  5328. -        floppy = unit + drive;
  5329. +    if (type == 0) {
  5330. +        if (!floppy->disktype) {
  5331. +            Probing = 1;
  5332. +            floppy->disktype  = disk_type + NUM_DISK_TYPES-1;
  5333. +            floppy->autoprobe = 1;
  5334.      } 
  5335. -     else
  5336. -    {
  5337. -     printk("Unknown Device !\n");
  5338. -     return;
  5339. +    } 
  5340. +    else {
  5341. +        /* user supplied disk type */
  5342. +        --type;
  5343. +        if (type >= NUM_DISK_TYPES) {
  5344. +            printk( "fd%d: invalid disk format", drive );
  5345. +            end_request( 0 );
  5346. +            goto repeat;
  5347. +        }
  5348. +        floppy->disktype = &disk_type[type];
  5349. +        floppy->autoprobe = 0;
  5350.      }
  5351.      
  5352. -    for (cnt = 0; cnt < 2; cnt++) {
  5353. -        block = CURRENT->sector + cnt;
  5354. -        if ((int)block > floppy->blocks) {
  5355. +    if (CURRENT->sector + 1 > floppy->disktype->blocks) {
  5356.              end_request(0);
  5357.              goto repeat;
  5358.          }
  5359.  
  5360. -        track = block / floppy->dtype->sects;
  5361. -        sector = block - track * floppy->dtype->sects;
  5362. -        data = CURRENT->buffer + 512 * cnt;
  5363. +    /* stop deselect timer */
  5364. +    del_timer( &motor_off_timer );
  5365.          
  5366. +    ReqCnt = 0;
  5367. +    ReqCmd = CURRENT->cmd;
  5368. +    ReqBlock = CURRENT->sector;
  5369. +    ReqBuffer = CURRENT->buffer;
  5370. +    setup_req_params( drive );
  5371. +    do_fd_action( drive );
  5372.  
  5373. -        switch (CURRENT->cmd) {
  5374. -          case READ:
  5375. -            atari_read(device,track,sector);
  5376. -            copy_buffer(trackdata,data);
  5377. -            break;
  5378. +    return;
  5379.  
  5380. -          case WRITE:
  5381. -            copy_buffer(data,trackdata);
  5382. -            atari_write(device,track,sector);
  5383. -            break;
  5384. +  the_end:
  5385. +    finish_fdc();
  5386. +}
  5387.  
  5388. -          default:
  5389. -            printk("do_fd_request: unknown command\n");
  5390. -            end_request(0);
  5391. -            goto repeat;
  5392. -        }
  5393. -    }
  5394.  
  5395. -    end_request(1);
  5396. -    goto repeat;
  5397. -}
  5398. +void do_fd_request(void)
  5399. +
  5400. +{     unsigned long flags;
  5401. +
  5402. +    save_flags(flags);
  5403. +    cli();
  5404. +    while( fdc_busy ) sleep_on( &fdc_wait );
  5405. +    fdc_busy = 1;
  5406. +    stdma_lock( floppy_irq, 0 );
  5407. +    restore_flags(flags);
  5408.  
  5409. -static void do_fd_request(void)
  5410. -{ 
  5411.      redo_fd_request();
  5412.  }
  5413.  
  5414. +
  5415.  static int fd_ioctl(struct inode *inode, struct file *filp,
  5416.              unsigned int cmd, unsigned long param)
  5417.  {
  5418. @@ -505,53 +1208,102 @@
  5419.      return -EINVAL;
  5420.  }
  5421.  
  5422. -/*======================================================================
  5423. -  Return unit ID number of given disk
  5424. -======================================================================*/
  5425. -#ifdef __notneeded__
  5426. -static unsigned long get_drive_id(int drive)
  5427. -{
  5428. -    return FD_HD_3;
  5429. -}
  5430. -#endif
  5431.  
  5432. -static void fd_probe(int drive)
  5433. +/* Initialize the 'unit' variable for drive 'drive' */
  5434. +
  5435. +static void fd_probe( int drive )
  5436.  {
  5437. -    unit[drive].type = NULL;
  5438. -    if (drive != 0)
  5439. -        /* At the moment, only one floppy drive is supported */
  5440. +    unit[drive].connected = 0;
  5441. +    unit[drive].disktype  = NULL;
  5442. +
  5443. +    if (!fd_test_drive_present( drive ))
  5444.          return;
  5445.  
  5446. -#ifdef CONFIG_FLOPPY_DD_ONLY
  5447. -    unit[drive].type = &drive_types[1]; /* DD */
  5448. -    dma_wd.fdc_speed = 0;
  5449. -#else
  5450. -    unit[drive].type = &drive_types[0]; /* HD */
  5451. -    dma_wd.fdc_speed = 3;
  5452. -#endif
  5453. +    unit[drive].connected = 1;
  5454. +    unit[drive].track     = 0;
  5455. +    unit[drive].steprate  = FDCSTEP_3;
  5456. +    MotorOn = 1;    /* from probe restore operation! */
  5457. +}
  5458. +
  5459. +
  5460. +/* This function tests the physical presence of a floppy drive (not
  5461. + * whether a disk is inserted). This is done by issuing a restore
  5462. + * command, waiting max. 2 seconds (that should be enough to move the
  5463. + * head across the whole disk) and looking at the state of the "TR00"
  5464. + * signal. This should now be raised if there is a drive connected
  5465. + * (and there is no hardware failure :-) Otherwise, the drive is
  5466. + * declared absent.
  5467. + */
  5468. +
  5469. +static int fd_test_drive_present( int drive )
  5470. +
  5471. +{    unsigned long timeout;
  5472. +    unsigned char status;
  5473. +    int              ok;
  5474. +    
  5475. +    if (drive > 1) return( 0 );
  5476. +    fd_select_drive( drive );
  5477. +
  5478. +    /* disable interrupt temporarily */
  5479. +    mfp.int_en_b &= 0x7f;
  5480. +    FDC_WRITE( FDCREG_CMD, FDCCMD_RESTORE | FDCSTEP_6 );
  5481. +
  5482. +    for( ok = 0, timeout = jiffies + 2*HZ+HZ/2; jiffies < timeout; ) {
  5483. +        if (!(mfp.par_dt_reg & 0x20))
  5484. +            break;
  5485. +    }
  5486. +
  5487. +    status = FDC_READ( FDCREG_STATUS );
  5488. +    ok = (status & FDCSTAT_TR00) != 0;
  5489.  
  5490. -    unit[drive].dtype = &data_types[0]; /* only one type */
  5491. -    unit[drive].track = -1;
  5492. +    /* force interrupt to abort restore operation (FDC would try
  5493. +     * about 50 seconds!) */
  5494. +    FDC_WRITE( FDCREG_CMD, FDCCMD_FORCI );
  5495. +    udelay(40);
  5496. +    status = FDC_READ( FDCREG_STATUS );
  5497. +    udelay(20);
  5498. +
  5499. +    if (ok) {
  5500. +        /* dummy seek command to make WP bit accessible */
  5501. +        FDC_WRITE( FDCREG_DATA, 0 );
  5502. +        FDC_WRITE( FDCREG_CMD, FDCCMD_SEEK );
  5503. +        while( mfp.par_dt_reg & 0x20 )
  5504. +            ;
  5505. +        status = FDC_READ( FDCREG_STATUS );
  5506. +    }
  5507.  
  5508. -    unit[drive].sects = unit[drive].dtype->sects * unit[drive].type->sect_mult;
  5509. -    unit[drive].blocks = unit[drive].type->heads * unit[drive].type->tracks *
  5510. -                         unit[drive].sects;
  5511. +    mfp.int_pn_b = 0x7f;
  5512. +    mfp.int_en_b |= 0x80;
  5513.  
  5514. -    unit[drive].disk = -1;
  5515. -    unit[drive].motor = 0;
  5516. -    unit[drive].busy = 0;
  5517. -    unit[drive].status = -1;
  5518. +    return( ok );
  5519.  }
  5520.  
  5521. -static void config_types(void)
  5522. +
  5523. +/* Look how many and which kind of drives are connected. If there are
  5524. + * floppies, additionally start the disk-change and motor-off timers.
  5525. + */
  5526. +
  5527. +static void config_types( void )
  5528. +
  5529.  {
  5530. -    int drive;
  5531. +    int drive, cnt = 0;
  5532. +
  5533. +    /* for probing drives, set the FDC speed to 8 MHz */
  5534. +    dma_wd.fdc_speed = 0;
  5535.  
  5536.      printk("Probing floppy drive(s):\n");
  5537. -    for (drive = 0; drive < FD_MAX_UNITS; drive++) {
  5538. -        fd_probe(drive);
  5539. -        if (unit[drive].type != NULL)
  5540. -            printk("%d: %s\n", drive, unit[drive].type->name);
  5541. +    for( drive = 0; drive < FD_MAX_UNITS; drive++ ) {
  5542. +        fd_probe( drive );
  5543. +        if (unit[drive].connected) {
  5544. +            printk("fd%d\n", drive);
  5545. +            ++cnt;
  5546. +        }
  5547. +    }
  5548. +
  5549. +    if (cnt > 0) {
  5550. +        START_MOTOR_OFF_TIMER( FD_MOTOR_OFF_DELAY );
  5551. +        if (cnt == 1) fd_select_drive( 0 );
  5552. +        START_CHECK_CHANGE_TIMER( CHECK_CHANGE_DELAY );
  5553.      }
  5554.  }
  5555.  
  5556. @@ -560,7 +1312,9 @@
  5557.   * /dev/PS0 etc), and disallows simultaneous access to the same
  5558.   * drive with different device numbers.
  5559.   */
  5560. -static int floppy_open(struct inode *inode, struct file *filp)
  5561. +
  5562. +static int floppy_open( struct inode *inode, struct file *filp )
  5563. +
  5564.  {
  5565.    int drive;
  5566.    int old_dev;
  5567. @@ -578,16 +1332,24 @@
  5568.    if (old_dev && old_dev != inode->i_rdev)
  5569.      invalidate_buffers(old_dev);
  5570.  
  5571. -  if (filp && filp->f_mode)
  5572. -    check_disk_change(inode->i_rdev);
  5573. -
  5574. +    if (filp && filp->f_mode) {
  5575. +        check_disk_change( inode->i_rdev );
  5576. +        if (filp->f_mode & 2) {
  5577. +            if (unit[drive].wpstat) {
  5578. +                floppy_release(inode, filp);
  5579. +                return -EROFS;
  5580. +            }
  5581. +        }
  5582. +    }
  5583.  
  5584.    return 0;
  5585.  }
  5586.  
  5587. -static void floppy_release(struct inode * inode, struct file * filp)
  5588. +
  5589. +static void floppy_release( struct inode * inode, struct file * filp )
  5590. +
  5591.  {
  5592. -  sync_dev(inode->i_rdev);
  5593. +    fsync_dev(inode->i_rdev);
  5594.    if (!fd_ref[inode->i_rdev & 3]--) {
  5595.      printk("floppy_release with fd_ref == 0");
  5596.      fd_ref[inode->i_rdev & 3] = 0;
  5597. @@ -607,25 +1369,37 @@
  5598.      block_fsync        /* fsync */
  5599.  };
  5600.  
  5601. -#ifdef __notneeded__
  5602. -static void fd_block_done(struct intframe *fp, void *data)
  5603. -{
  5604. -}
  5605. -#endif
  5606.  
  5607.  void atari_floppy_init(void)
  5608. -{
  5609. -  int i;
  5610. +
  5611. +{    int i;
  5612.  
  5613.    if (register_blkdev(MAJOR_NR,"fd",&floppy_fops)) {
  5614.      printk("Unable to get major %d for floppy\n",MAJOR_NR);
  5615.      return;
  5616.    }
  5617. +
  5618.    /* initialize variables */
  5619. -  selected = -1;
  5620. +    SelectedDrive = -1;
  5621. +#ifdef TRACKBUFFER
  5622. +    BufferDrive = -1;
  5623. +    error_drive = -1;
  5624. +#endif
  5625.  
  5626. -  /* memory returned by atari_stram_alloc is identity mapped */
  5627. -  trackdata = atari_stram_alloc (512);
  5628. +    /* initialize motor-off timer */
  5629. +    timer_table[FLOPPY_TIMER].fn = check_change;
  5630. +    timer_active &= ~(1 << FLOPPY_TIMER);
  5631. +
  5632. +    /* The ST-Ram buffers are now allocated in
  5633. +     * atari_floppy_alloc_buffers(), which is called by
  5634. +     * blk_dev_init(). This is because floppy_init() is called after
  5635. +     * mem_init() and stram_alloc() isn't possible any more here.
  5636. +     */
  5637. +    PhysDMABuffer = (unsigned long) VTOP(DMABuffer);
  5638. +#ifdef TRACKBUFFER
  5639. +    PhysTrackBuffer = (unsigned long) VTOP(TrackBuffer);
  5640. +    BufferDrive = BufferSide = BufferTrack = -1;
  5641. +#endif
  5642.  
  5643.    for (i = 0; i < FD_MAX_UNITS; i++) {
  5644.        unit[i].track = -1;
  5645. @@ -636,3 +1410,25 @@
  5646.  
  5647.    config_types();
  5648.  }
  5649. +
  5650. +
  5651. +/* This function is called by blk_dev_init() to give the floppy driver
  5652. + * a chance to allocate some ST-Ram
  5653. + */
  5654. +
  5655. +unsigned long atari_floppy_alloc_buffers( unsigned long mem_start )
  5656. +
  5657. +{
  5658. +#ifdef TRACKBUFFER
  5659. +    DMABuffer = atari_stram_alloc( (MAX_SECTORS+1)*512, &mem_start );
  5660. +    TrackBuffer = DMABuffer + 512;
  5661. +#else
  5662. +    DMABuffer = atari_stram_alloc( 512, &mem_start );
  5663. +#endif
  5664. +    return( mem_start );
  5665. +}
  5666. +
  5667. +
  5668. +/* Local Variables: */
  5669. +/* tab-width: 4     */
  5670. +/* End:             */
  5671. diff -ubr -x RCS -x *.[ao] -x .depend -x .version -x .config -x System.map -x vmlinux -x bootstrap -x *~ -x config.old -x *.orig -x *.rej -x *# -x version.h -x autoconf.h --new-file linux-0.9pl3/drivers/block/blk.h linux-0.9pl4/drivers/block/blk.h
  5672. --- linux-0.9pl3/drivers/block/blk.h    Sun Aug 14 10:30:43 1994
  5673. +++ linux-0.9pl4/drivers/block/blk.h    Mon Nov  7 22:13:16 1994
  5674. @@ -27,8 +27,8 @@
  5675.  /*
  5676.   * Ok, this is an expanded form so that we can use the same
  5677.   * request for paging requests when that is implemented. In
  5678. - * paging, 'bh' is NULL, and 'waiting' is used to wait for
  5679. - * read/write completion.
  5680. + * paging, 'bh' is NULL, and the semaphore is used to wait
  5681. + * for read/write completion.
  5682.   */
  5683.  struct request {
  5684.      int dev;        /* -1 if no request */
  5685. @@ -38,7 +38,7 @@
  5686.      unsigned long nr_sectors;
  5687.      unsigned long current_nr_sectors;
  5688.      char * buffer;
  5689. -    struct task_struct * waiting;
  5690. +    struct semaphore * sem;
  5691.      struct buffer_head * bh;
  5692.      struct buffer_head * bhtail;
  5693.      struct request * next;
  5694. @@ -205,6 +205,15 @@
  5695.  #define DEVICE_ON(device)
  5696.  #define DEVICE_OFF(device)
  5697.  
  5698. +#elif (MAJOR_NR == ACSI_MAJOR)
  5699. +
  5700. +#define DEVICE_NAME "ACSI"
  5701. +#define DEVICE_INTR do_acsi
  5702. +#define DEVICE_REQUEST do_acsi_request
  5703. +#define DEVICE_NR(device) (MINOR(device) >> 4)
  5704. +#define DEVICE_ON(device)
  5705. +#define DEVICE_OFF(device)
  5706. +
  5707.  #else
  5708.  
  5709.  #error "unknown blk device"
  5710. @@ -252,7 +261,6 @@
  5711.  {
  5712.      struct request * req;
  5713.      struct buffer_head * bh;
  5714. -    struct task_struct * p;
  5715.  
  5716.      req = CURRENT;
  5717.      req->errors = 0;
  5718. @@ -270,6 +278,7 @@
  5719.          req->bh = bh->b_reqnext;
  5720.          bh->b_reqnext = NULL;
  5721.          bh->b_uptodate = uptodate;
  5722. +        if (!uptodate) bh->b_req = 0; /* So no "Weird" errors */
  5723.          unlock_buffer(bh);
  5724.          if ((bh = req->bh) != NULL) {
  5725.              req->current_nr_sectors = bh->b_size >> 9;
  5726. @@ -283,12 +292,8 @@
  5727.      }
  5728.      DEVICE_OFF(req->dev);
  5729.      CURRENT = req->next;
  5730. -    if ((p = req->waiting) != NULL) {
  5731. -        req->waiting = NULL;
  5732. -        p->state = TASK_RUNNING;
  5733. -        if (p->counter > current->counter)
  5734. -            need_resched = 1;
  5735. -    }
  5736. +    if (req->sem != NULL)
  5737. +        up(req->sem);
  5738.      req->dev = -1;
  5739.      wake_up(&wait_for_request);
  5740.  }
  5741. diff -ubr -x RCS -x *.[ao] -x .depend -x .version -x .config -x System.map -x vmlinux -x bootstrap -x *~ -x config.old -x *.orig -x *.rej -x *# -x version.h -x autoconf.h --new-file linux-0.9pl3/drivers/block/falhd.c linux-0.9pl4/drivers/block/falhd.c
  5742. --- linux-0.9pl3/drivers/block/falhd.c    Tue Sep 27 22:21:42 1994
  5743. +++ linux-0.9pl4/drivers/block/falhd.c    Mon Nov  7 22:14:45 1994
  5744. @@ -20,11 +20,6 @@
  5745.   *  Modified 1994 for ATARI IDE controller support by Bjoern Brauel
  5746.   */
  5747.   
  5748. -/*
  5749. - *  08/08/94 changes for proper Seagate recognition, debug messages 
  5750. - *  by Helmut Neukirchen, hn@pool.informatik.rwth-aachen
  5751. - */
  5752. -
  5753.  #include <linux/errno.h>
  5754.  #include <linux/signal.h>
  5755.  #include <linux/sched.h>
  5756. @@ -38,6 +33,7 @@
  5757.  #include <linux/atarihw.h>
  5758.  #include <linux/atarihdreg.h>
  5759.  #include <linux/atariints.h>
  5760. +#include <linux/atari_stdma.h>
  5761.  
  5762.  #include <asm/system.h>
  5763.  #include <asm/io.h>
  5764. @@ -53,6 +49,7 @@
  5765.  #define RECAL_FREQ      4    /* Recalibrate every 4th retry */
  5766.  #define MAX_HD        2
  5767.  
  5768. +extern void hd_interrupt (struct intframe *, void *);
  5769.  static void recal_intr(void);
  5770.  static void bad_rw_intr(void);
  5771.  
  5772. @@ -70,7 +67,7 @@
  5773.  struct hd_i_struct {
  5774.      unsigned int head,sect,cyl,wpcom,lzone,ctl;
  5775.      };
  5776. -static struct hd_i_struct hd_info[] = { {0,0,0,0,0,0},{0,0,0,0,0,0} };
  5777. +struct hd_i_struct hd_info[] = { {0,0,0,0,0,0},{0,0,0,0,0,0} };
  5778.  static int NR_HD = 0;
  5779.  
  5780.  static struct hd_struct hd[MAX_HD<<6]={{0,0},};
  5781. @@ -282,7 +279,7 @@
  5782.   * doing a reset and a retry seems to result in an eternal loop. Right now I
  5783.   * ignore it, and just set the timeout.
  5784.   */
  5785. -static void unexpected_hd_interrupt(void)
  5786. +void unexpected_hd_interrupt(void)
  5787.  {
  5788.      printk("Unexpected HD interrupt\n");
  5789.      SET_TIMER;
  5790. @@ -357,8 +354,9 @@
  5791.          MINOR(CURRENT->dev), CURRENT->sector, i, CURRENT-> 
  5792.          buffer);
  5793.  #endif
  5794. -    if (!i || (CURRENT->bh && !SUBSECTOR(i)))
  5795. +    if (!i || (CURRENT->bh && !SUBSECTOR(i))) {
  5796.          end_request(1);
  5797. +    }
  5798.      if (i > 0) {
  5799.          SET_INTR(&read_intr);
  5800.          return;
  5801. @@ -398,8 +396,9 @@
  5802.      i = --CURRENT->nr_sectors;
  5803.      --CURRENT->current_nr_sectors;
  5804.      CURRENT->buffer += 512;
  5805. -    if (!i || (CURRENT->bh && !SUBSECTOR(i)))
  5806. +    if (!i || (CURRENT->bh && !SUBSECTOR(i))) {
  5807.          end_request(1);
  5808. +    }
  5809.      if (i > 0) {
  5810.        SET_INTR(&write_intr);
  5811.          port_write(HD_DATA,CURRENT->buffer,15);
  5812. @@ -462,7 +461,7 @@
  5813.      nsect = CURRENT->nr_sectors;
  5814.      if (dev >= (NR_HD<<6) || block >= hd[dev].nr_sects) {
  5815.  #ifdef DEBUG
  5816. -        printk("hd : attempted read for sector %d past end of device at sector %d.\n",
  5817. +        printk("hd%d : attempted read for sector %d past end of device at sector %d.\n",
  5818.                 block, hd[dev].nr_sects);
  5819.  #endif
  5820.          end_request(0);
  5821. @@ -604,33 +603,26 @@
  5822.      NULL        /* next */
  5823.  };
  5824.      
  5825. -/*te******************************************************************
  5826. +/*******************************************************************
  5827.   *
  5828.   * hd_interrupt routine
  5829.   *   Test, if this is a harddisk interrupt and call
  5830.   *   the irq handler
  5831.   *   Otherwise ignore this interrupt.
  5832.   *
  5833. - ********************************************************/
  5834. -static void hd_interrupt (struct intframe *fp, void *data)
  5835. + *******************************************************************/
  5836. +extern void hd_interrupt (struct intframe *fp, void *data)
  5837.  {
  5838. -void (*hd_irq_handler)(void) = DEVICE_INTR;
  5839. +  void (*hd_irq_handler)(void) = DEVICE_INTR;
  5840.  
  5841. -/* Test, if this is a harddisk interrupt. MSB(0xdd2030) = 1 (Amiga only) */
  5842. -/* GK: this has to be changed for Atari FALCON.
  5843. - * Is there any way to determine if harddisk did interrupt ?
  5844. - */
  5845. -if (1 /*inb (HD_IRQ_TEST) & 0x7f*/)
  5846. -  {
  5847.    DEVICE_INTR = NULL;
  5848.    timer_active &= ~(1 << HD_TIMER);
  5849.  
  5850. -  if (hd_irq_handler)
  5851. -/*    hd_irq_handler = unexpected_hd_interrupt;*/
  5852. +  if (!hd_irq_handler)
  5853. +    hd_irq_handler = unexpected_hd_interrupt;
  5854.      hd_irq_handler ();
  5855.  
  5856.    return;
  5857. -  } 
  5858.  }
  5859.  
  5860.  /*te******************************************************************
  5861. @@ -671,12 +663,9 @@
  5862.    /* Test, if ready to read */
  5863.    for (i=0; i<HD_ID_RETRIES; i++)
  5864.      {
  5865. -    if ((inb_p(HD_STATUS) & (DRQ_STAT|READY_STAT)) == (DRQ_STAT|READY_STAT)) /* ++hn: Detect Seagate drives properly */
  5866. +    if (inb_p (HD_STATUS) & DRQ_STAT)
  5867.        {
  5868.        drive_found = 1;
  5869. -#ifdef DEBUG
  5870. -      printk("hd%d: WIN_IDENTIFY: status = 0x%hx\n", drive, inb_p(HD_STATUS));
  5871. -#endif
  5872.        break;
  5873.        }
  5874.      }
  5875. @@ -693,31 +682,26 @@
  5876.      hd_info[drive].sect   = Identify [6];
  5877.      NR_HD++;
  5878.      Identify [47] = 0x0000;
  5879. -    printk ("hd%c: %s\n", (char)drive+'a', (unsigned char *)&Identify [27]); /* ++hn: use hda/hdb naming for the user-messages  */
  5880. +    printk ("hd%d: %s\n", drive, (unsigned char *)&Identify [27]);
  5881.      printk ("     cyl %d, sector %d, head %d.\n",
  5882.                                               hd_info[drive].cyl,
  5883.                                               hd_info[drive].sect,
  5884.                                               hd_info[drive].head);
  5885.      }
  5886.    else
  5887. -    printk ("hd%c not found.\n", (char)drive+'a'); /* ++hn: use hda/hdb naming for the user-messages */
  5888. +    printk ("hd%d not found.\n", drive);
  5889.    }
  5890.  sti ();                             /* Enable interrupts */
  5891.  
  5892.  /* Add the interrupt handler */
  5893.  if (NR_HD)
  5894. -{
  5895. -  if (!add_isr (IRQ_MFP_FDC, hd_interrupt, 0, NULL))
  5896. +/*  if (!add_isr (IRQ_MFP_FDC, hd_interrupt, 0, NULL))
  5897.      {
  5898.      printk ("HD: Can't add interrupt handler for harddisk device.\n");
  5899.      NR_HD = 0;
  5900. -    }
  5901. -  else
  5902. -    {
  5903. +    } */
  5904.      mfp.int_en_b |= 0x80;    /* enable int */
  5905.      mfp.int_mk_b |= 0x80;    /* not masked */
  5906. -    }
  5907. -}
  5908.  
  5909.  i = NR_HD;
  5910.  while (i-- > 0)
  5911. diff -ubr -x RCS -x *.[ao] -x .depend -x .version -x .config -x System.map -x vmlinux -x bootstrap -x *~ -x config.old -x *.orig -x *.rej -x *# -x version.h -x autoconf.h --new-file linux-0.9pl3/drivers/block/ll_rw_blk.c linux-0.9pl4/drivers/block/ll_rw_blk.c
  5912. --- linux-0.9pl3/drivers/block/ll_rw_blk.c    Sun Aug 14 10:30:43 1994
  5913. +++ linux-0.9pl4/drivers/block/ll_rw_blk.c    Mon Nov  7 22:15:16 1994
  5914. @@ -29,6 +29,14 @@
  5915.  extern u_long sbpcd_init(u_long, u_long);
  5916.  #endif CONFIG_SBPCD
  5917.  
  5918. +#ifdef CONFIG_ATARI_ACSI
  5919. +extern u_long acsi_init(u_long, u_long);
  5920. +#endif CONFIG_ATARI_ACSI
  5921. +
  5922. +#ifdef CONFIG_ATARI
  5923. +#include <linux/atarihw.h>    /* for atari_stram_alloc() */
  5924. +#endif
  5925. +
  5926.  /*
  5927.   * The request-struct contains all necessary data
  5928.   * to load a nr of sectors into memory
  5929. @@ -234,16 +242,16 @@
  5930.   * they start processing an entry.  For this reason it is safe to continue
  5931.   * to add links to the top entry for scsi devices.
  5932.   */
  5933. -    if ((major == HD_MAJOR
  5934. +    if ((major == HD_MAJOR || major == ACSI_MAJOR
  5935.           || major == SCSI_DISK_MAJOR
  5936.           || major == SCSI_CDROM_MAJOR)
  5937.          && (req = blk_dev[major].current_request))
  5938.      {
  5939. -            if (major == HD_MAJOR)
  5940. +            if (major == HD_MAJOR || major == ACSI_MAJOR)
  5941.              req = req->next;
  5942.          while (req) {
  5943.              if (req->dev == bh->b_dev &&
  5944. -                !req->waiting &&
  5945. +                !req->sem &&
  5946.                  req->cmd == rw &&
  5947.                  req->sector + req->nr_sectors == sector &&
  5948.                  req->nr_sectors < 254)
  5949. @@ -257,7 +265,7 @@
  5950.              }
  5951.  
  5952.              if (req->dev == bh->b_dev &&
  5953. -                !req->waiting &&
  5954. +                !req->sem &&
  5955.                  req->cmd == rw &&
  5956.                  req->sector - count == sector &&
  5957.                  req->nr_sectors < 254)
  5958. @@ -302,7 +310,7 @@
  5959.      req->nr_sectors = count;
  5960.      req->current_nr_sectors = count;
  5961.      req->buffer = bh->b_data;
  5962. -    req->waiting = NULL;
  5963. +    req->sem = NULL;
  5964.      req->bh = bh;
  5965.      req->bhtail = bh;
  5966.      req->next = NULL;
  5967. @@ -313,6 +321,7 @@
  5968.  {
  5969.      struct request * req;
  5970.      unsigned int major = MAJOR(dev);
  5971. +    struct semaphore sem = MUTEX_LOCKED;
  5972.  
  5973.      if (major >= MAX_BLKDEV || !(blk_dev[major].request_fn)) {
  5974.          printk("Trying to read nonexistent block-device %04x (%d)\n",dev,page*8);
  5975. @@ -334,12 +343,11 @@
  5976.      req->nr_sectors = 8;
  5977.      req->current_nr_sectors = 8;
  5978.      req->buffer = buffer;
  5979. -    req->waiting = current;
  5980. +    req->sem = &sem;
  5981.      req->bh = NULL;
  5982.      req->next = NULL;
  5983. -    current->state = TASK_SWAPPING;
  5984.      add_request(major+blk_dev,req);
  5985. -    schedule();
  5986. +    down(&sem);
  5987.  }
  5988.  
  5989.  /* This function can be used to request a number of buffers from a block
  5990. @@ -441,6 +449,7 @@
  5991.      int buffersize;
  5992.      struct request * req;
  5993.      unsigned int major = MAJOR(dev);
  5994. +    struct semaphore sem = MUTEX_LOCKED;
  5995.  
  5996.      if (major >= MAX_BLKDEV || !(blk_dev[major].request_fn)) {
  5997.          printk("ll_rw_swap_file: trying to swap nonexistent block-device\n");
  5998. @@ -469,12 +478,11 @@
  5999.          req->nr_sectors = buffersize >> 9;
  6000.          req->current_nr_sectors = buffersize >> 9;
  6001.          req->buffer = buf;
  6002. -        req->waiting = current;
  6003. +        req->sem = &sem;
  6004.          req->bh = NULL;
  6005.          req->next = NULL;
  6006. -        current->state = TASK_UNINTERRUPTIBLE;
  6007.          add_request(major+blk_dev,req);
  6008. -        schedule();
  6009. +        down(&sem);
  6010.      }
  6011.  }
  6012.  
  6013. @@ -508,7 +516,21 @@
  6014.  #ifdef CONFIG_SBPCD
  6015.      mem_start = sbpcd_init(mem_start, mem_end);
  6016.  #endif CONFIG_SBPCD
  6017. +#ifdef CONFIG_ATARI_ACSI
  6018. +    mem_start = acsi_init(mem_start, mem_end);
  6019. +#endif CONFIG_ATARI_ACSI
  6020.      if (boot_info.ramdisk_size)
  6021.          mem_start += rd_init(mem_start, boot_info.ramdisk_size*1024);
  6022. +#ifdef CONFIG_ATARI
  6023. +    /* ++roman: Call a function of the Atari floppy driver here that
  6024. +     * allocates some ST-Ram buffers, because atari_stram_alloc()
  6025. +     * isn't possible in atari_floppy_init() any more.
  6026. +     */
  6027. +    if (boot_info.machtype == MACH_ATARI) {
  6028. +        extern unsigned long
  6029. +            atari_floppy_alloc_buffers( unsigned long mem_start );
  6030. +        mem_start = atari_floppy_alloc_buffers( mem_start );
  6031. +    }
  6032. +#endif
  6033.      return mem_start;
  6034.  }
  6035. diff -ubr -x RCS -x *.[ao] -x .depend -x .version -x .config -x System.map -x vmlinux -x bootstrap -x *~ -x config.old -x *.orig -x *.rej -x *# -x version.h -x autoconf.h --new-file linux-0.9pl3/drivers/char/atari_SCC.c linux-0.9pl4/drivers/char/atari_SCC.c
  6036. --- linux-0.9pl3/drivers/char/atari_SCC.c    Sun Aug 14 10:30:41 1994
  6037. +++ linux-0.9pl4/drivers/char/atari_SCC.c    Mon Nov 21 18:09:01 1994
  6038. @@ -25,11 +25,11 @@
  6039.  #include <linux/atariints.h>
  6040.  
  6041.  #include "serial.h"
  6042. -#include "atari_MFPser.h"
  6043. +#include "atari_SCC.h"
  6044.  
  6045.  
  6046.  void atari_init_SCC( struct async_struct *info, SERTYPE type,
  6047. -                     int tt_flag, void *ri_addr,
  6048. +                     int channel, void *ri_addr,
  6049.                       unsigned char ri_bitno, unsigned char ri_active )
  6050.  
  6051.  {    
  6052. diff -ubr -x RCS -x *.[ao] -x .depend -x .version -x .config -x System.map -x vmlinux -x bootstrap -x *~ -x config.old -x *.orig -x *.rej -x *# -x version.h -x autoconf.h --new-file linux-0.9pl3/drivers/char/atari_SCC.h linux-0.9pl4/drivers/char/atari_SCC.h
  6053. --- linux-0.9pl3/drivers/char/atari_SCC.h    Sun Sep 25 16:19:40 1994
  6054. +++ linux-0.9pl4/drivers/char/atari_SCC.h    Mon Nov 21 18:09:02 1994
  6055. @@ -314,7 +314,7 @@
  6056.  
  6057.  /***************************** Prototypes *****************************/
  6058.  
  6059. -void atari_init_SCC( struct async_struct *info, SERTYPE type, int tt_flag,
  6060. +void atari_init_SCC( struct async_struct *info, SERTYPE type, int channel,
  6061.                       void *ri_addr, unsigned char ri_bitno, unsigned char
  6062.                       ri_active );
  6063.  
  6064. @@ -337,6 +337,7 @@
  6065.   * I'm not sure, correct me please!), that gives 4 nops for a TT (32
  6066.   * MHz) (2 would be sufficient for the Falcon (16 MHz), but looking at
  6067.   * boot_info.bi_atari.model at runtime takes longer than 2 nop's...)
  6068. + * ++andreas: nop needs only 2 cycles, seven of them are needed.
  6069.   */
  6070.  
  6071.  static __inline__ void scc_reg_delay( void )
  6072. diff -ubr -x RCS -x *.[ao] -x .depend -x .version -x .config -x System.map -x vmlinux -x bootstrap -x *~ -x config.old -x *.orig -x *.rej -x *# -x version.h -x autoconf.h --new-file linux-0.9pl3/drivers/char/atarimouse.c linux-0.9pl4/drivers/char/atarimouse.c
  6073. --- linux-0.9pl3/drivers/char/atarimouse.c    Sun Aug 14 10:30:41 1994
  6074. +++ linux-0.9pl4/drivers/char/atarimouse.c    Mon Nov 21 18:09:02 1994
  6075. @@ -1,6 +1,11 @@
  6076.  /*
  6077.   * Atari Mouse Driver for Linux
  6078.   * by Robert de Vries (robert@and.nl) 19Jul93
  6079. + *
  6080. + * 16 Nov 1994 Andreas Schwab
  6081. + * Compatibility with busmouse
  6082. + * Support for three button mouse (shamelessly stolen from MiNT)
  6083. + * third button wired to one of the joystick directions on joystick 1
  6084.   */
  6085.  
  6086.  #include <linux/sched.h>
  6087. @@ -11,14 +16,21 @@
  6088.  #include <asm/segment.h>
  6089.  
  6090.  static struct mouse_status mouse;
  6091. +int atari_mouse_buttons;
  6092.  
  6093.  void atari_mouse_interrupt(char *buf)
  6094.  {
  6095. +    int buttons;
  6096. +
  6097.  /*    ikbd_mouse_disable(); */
  6098.  
  6099. -    mouse.buttons = buf[0] & 0x3;
  6100. -    mouse.dx = buf[1];
  6101. -    mouse.dy = buf[2];
  6102. +    buttons = ((buf[0] & 1 ? 1 : 0)
  6103. +           | (buf[0] & 2 ? 4 : 0)
  6104. +           | (atari_mouse_buttons & 2));
  6105. +    atari_mouse_buttons = buttons;
  6106. +    mouse.buttons = ~buttons & 7;
  6107. +    mouse.dx += buf[1];
  6108. +    mouse.dy += buf[2];
  6109.      mouse.ready = 1;
  6110.      wake_up_interruptible(&mouse.wait);
  6111.  
  6112. @@ -43,6 +55,10 @@
  6113.      return -EBUSY;
  6114.      mouse.active = 1;
  6115.      mouse.ready = 0;
  6116. +    mouse.dx = mouse.dy = 0;
  6117. +    atari_mouse_buttons = 0;
  6118. +    ikbd_mouse_y0_bot ();
  6119. +    ikbd_mouse_thresh (1, 1);
  6120.      ikbd_mouse_rel_pos();
  6121.      return 0;
  6122.  }
  6123. @@ -54,21 +70,32 @@
  6124.  
  6125.  static int read_mouse(struct inode *inode, struct file *file, char *buffer, int count)
  6126.  {
  6127. -    int i;
  6128. +    int dx, dy, buttons;
  6129.  
  6130.      if (count < 3)
  6131.      return -EINVAL;
  6132.      if (!mouse.ready)
  6133.      return -EAGAIN;
  6134.      /* ikbd_mouse_disable */
  6135. -    put_fs_byte(mouse.buttons, buffer++);
  6136. -    put_fs_byte(mouse.dx, buffer++);
  6137. -    put_fs_byte(mouse.dy, buffer++);
  6138. -    for (i = 3; i < count; i++)
  6139. -    put_fs_byte(0, buffer++);
  6140. +    dx = mouse.dx;
  6141. +    dy = mouse.dy;
  6142. +    buttons = mouse.buttons;
  6143. +    if (dx > 127)
  6144. +      dx = 127;
  6145. +    else if (dx < -128)
  6146. +      dx = -128;
  6147. +    if (dy > 127)
  6148. +      dy = 127;
  6149. +    else if (dy < -128)
  6150. +      dy = -128;
  6151. +    mouse.dx -= dx;
  6152. +    mouse.dy -= dy;
  6153.      mouse.ready = 0;
  6154.      /* ikbd_mouse_rel_pos(); */
  6155. -    return i;
  6156. +    put_fs_byte(buttons | 0x80, buffer++);
  6157. +    put_fs_byte((char) dx, buffer++);
  6158. +    put_fs_byte((char) dy, buffer++);
  6159. +    return 3;
  6160.  }
  6161.  
  6162.  static int mouse_select(struct inode *inode, struct file *file, int sel_type, select_table *wait)
  6163. Binary files linux-0.9pl3/drivers/char/bdflush-1.4.tar.gz and linux-0.9pl4/drivers/char/bdflush-1.4.tar.gz differ
  6164. diff -ubr -x RCS -x *.[ao] -x .depend -x .version -x .config -x System.map -x vmlinux -x bootstrap -x *~ -x config.old -x *.orig -x *.rej -x *# -x version.h -x autoconf.h --new-file linux-0.9pl3/drivers/char/console.c linux-0.9pl4/drivers/char/console.c
  6165. --- linux-0.9pl3/drivers/char/console.c    Sun Aug 14 10:30:40 1994
  6166. +++ linux-0.9pl4/drivers/char/console.c    Mon Nov 21 18:09:03 1994
  6167. @@ -82,7 +82,9 @@
  6168.  static void clear_selection(void);
  6169.  
  6170.  /* Variables for selection control. */
  6171. -#define SEL_BUFFER_SIZE TTY_BUF_SIZE
  6172. +/* The original size (1024) is to small for my console - FN */
  6173. +#define SEL_BUFFER_SIZE 4096
  6174. +/* #define SEL_BUFFER_SIZE TTY_BUF_SIZE */
  6175.  static int sel_cons;
  6176.  static int sel_start = -1;
  6177.  static int sel_end;
  6178. @@ -93,8 +95,7 @@
  6179.  extern void register_console(void (*proc)(const char *));
  6180.  extern void compute_shiftstate(void);
  6181.  
  6182. -static int console_blanked = 0;
  6183. -static int can_do_color = 0;
  6184. +int console_blanked = 0;
  6185.  static int printable = 0;
  6186.  
  6187.  struct condata vc_cons[NR_CONSOLES];
  6188. @@ -105,6 +106,7 @@
  6189.  #define    y        (vc_cons[currcons].vc_y)
  6190.  #define top        (vc_cons[currcons].vc_top)
  6191.  #define bottom        (vc_cons[currcons].vc_bottom)
  6192. +#define pos        (vc_cons[currcons].vc_pos)
  6193.  /*
  6194.   * Arno:
  6195.   * On the 680x0 we could have screens with different sizes (at least
  6196. @@ -112,6 +114,7 @@
  6197.   * of using a global variable like the original PC code.
  6198.   */
  6199.  #define    video_num_columns    (vc_cons[currcons].vc_cols)
  6200. +#define    video_size_row        (vc_cons[currcons].vc_size_row)
  6201.  #define    video_num_lines        (vc_cons[currcons].vc_rows)
  6202.  #define    state        (vc_cons[currcons].vc_state)
  6203.  #define    npar        (vc_cons[currcons].vc_npar)
  6204. @@ -125,6 +128,7 @@
  6205.  #define    G1_charset    (vc_cons[currcons].vc_G1_charset)
  6206.  #define    saved_G0    (vc_cons[currcons].vc_saved_G0)
  6207.  #define    saved_G1    (vc_cons[currcons].vc_saved_G1)
  6208. +#define    video_mem_start    (vc_cons[currcons].vc_video_mem_start)
  6209.  #define    video_erase_char (vc_cons[currcons].vc_video_erase_char)    
  6210.  #define    decscnm        (vc_cons[currcons].vc_decscnm)
  6211.  #define    decom        (vc_cons[currcons].vc_decom)
  6212. @@ -132,6 +136,7 @@
  6213.  #define    deccm        (vc_cons[currcons].vc_deccm)
  6214.  #define    decim        (vc_cons[currcons].vc_decim)
  6215.  #define    need_wrap    (vc_cons[currcons].vc_need_wrap)
  6216. +#define    can_do_color    (vc_cons[currcons].vc_can_do_color)
  6217.  #define    color        (vc_cons[currcons].vc_color)
  6218.  #define    s_color        (vc_cons[currcons].vc_s_color)
  6219.  #define    def_color    (vc_cons[currcons].vc_def_color)
  6220. @@ -281,6 +286,7 @@
  6221.              y = max_y - 1;
  6222.          else
  6223.              y = new_y;
  6224. +    pos = video_mem_start + y * video_num_columns + x;
  6225.      need_wrap = 0;
  6226.  }
  6227.  
  6228. @@ -319,9 +325,22 @@
  6229.  static void scrup(int currcons, unsigned int t, unsigned int b,
  6230.            int nr)
  6231.  {
  6232. +    unsigned short *p;
  6233. +    int i;
  6234. +
  6235.      if (b > video_num_lines || t >= b)
  6236.          return;
  6237.  
  6238. +    memmove (video_mem_start + t * video_num_columns,
  6239. +         video_mem_start + (t + nr) * video_num_columns,
  6240. +         (b - t - nr) * video_num_columns * 2);
  6241. +
  6242. +    p = video_mem_start + (b - nr) * video_num_columns;
  6243. +    for (i = nr * video_num_columns; i > 0; i--)
  6244. +      *p++ = video_erase_char;
  6245. +
  6246. +    if (currcons != fg_console)
  6247. +      return;
  6248.  /*
  6249.   * Arno:
  6250.   * Scrolling has now been moved to amicon.c where it should have
  6251. @@ -336,9 +355,22 @@
  6252.  static void scrdown(int currcons, unsigned int t, unsigned int b,
  6253.              int nr)
  6254.  {
  6255. +    unsigned short *p;
  6256. +    int i;
  6257. +
  6258.      if (b > video_num_lines || t >= b)
  6259.          return;
  6260.  
  6261. +    memmove (video_mem_start + (t + nr) * video_num_columns,
  6262. +         video_mem_start + t * video_num_columns,
  6263. +         (b - t - nr) * video_num_columns * 2);
  6264. +
  6265. +    p = video_mem_start + t * video_num_columns;
  6266. +    for (i = nr * video_num_columns; i > 0; i--)
  6267. +      *p++ = video_erase_char;
  6268. +
  6269. +    if (currcons != fg_console)
  6270. +      return;
  6271.  /*
  6272.   * Arno:
  6273.   * Scrolling has now been moved to amicon.c where it should have
  6274. @@ -353,6 +385,7 @@
  6275.  {
  6276.      if (y+1<bottom) {
  6277.          y++;
  6278. +        pos += video_num_columns;
  6279.          return;
  6280.      } else 
  6281.          scrup(currcons,top,bottom, 1);
  6282. @@ -363,6 +396,7 @@
  6283.  {
  6284.      if (y>top) {
  6285.          y--;
  6286. +        pos -= video_num_columns;
  6287.          return;
  6288.      } else
  6289.          scrdown(currcons,top,bottom, 1);
  6290. @@ -371,12 +405,14 @@
  6291.  
  6292.  static inline void cr(int currcons)
  6293.  {
  6294. +    pos -= x;
  6295.      need_wrap = x = 0;
  6296.  }
  6297.  
  6298.  static inline void bs(int currcons)
  6299.  {
  6300.      if (x) {
  6301. +        pos--;
  6302.          x--;
  6303.          need_wrap = 0;
  6304.      }
  6305. @@ -396,41 +432,77 @@
  6306.  
  6307.  static void csi_J(int currcons, int vpar)
  6308.  {
  6309. +    unsigned long count;
  6310. +    unsigned short *start;
  6311. +
  6312.      switch (vpar) {
  6313.          case 0:    /* erase from cursor to end of display */
  6314. +            count = (video_mem_start
  6315. +                 + video_num_columns * video_num_lines
  6316. +                 - pos);
  6317. +            start = pos;
  6318. +            if (currcons != fg_console)
  6319. +              break;
  6320.              /* 680x0 do in two stages */
  6321.              sw->con_clear(&vc_cons[currcons],y,x,1,video_num_columns-x);
  6322.              sw->con_clear(&vc_cons[currcons],y+1,0,video_num_lines-y-1, video_num_columns);
  6323.              break;
  6324.          case 1:    /* erase from start to cursor */
  6325. +            count = pos - video_mem_start + 1;
  6326. +            start = video_mem_start;
  6327. +            if (currcons != fg_console)
  6328. +              break;
  6329.              /* 680x0 do in two stages */
  6330.              sw->con_clear(&vc_cons[currcons],0,0,y, video_num_columns);
  6331.              sw->con_clear(&vc_cons[currcons],y,0,1,x + 1);
  6332.              break;
  6333.          case 2: /* erase whole display */
  6334. +            count = video_num_columns * video_num_lines;
  6335. +            start = video_mem_start;
  6336. +            if (currcons != fg_console)
  6337. +              break;
  6338.              sw->con_clear(&vc_cons[currcons],0,0,video_num_lines, video_num_columns);
  6339.              break;
  6340.          default:
  6341.              return;
  6342.      }
  6343. +    while (count-- > 0)
  6344. +      *start++ = video_erase_char;
  6345.      need_wrap = 0;
  6346.  }
  6347.  
  6348.  static void csi_K(int currcons, int vpar)
  6349.  {
  6350. +    unsigned long count;
  6351. +    unsigned short *start;
  6352. +
  6353.      switch (vpar) {
  6354.          case 0:    /* erase from cursor to end of line */
  6355. +            count = video_num_columns - x;
  6356. +            start = pos;
  6357. +            if (currcons != fg_console)
  6358. +              break;
  6359.              sw->con_clear(&vc_cons[currcons],y,x,1,video_num_columns-x);
  6360.              break;
  6361.          case 1:    /* erase from start of line to cursor */
  6362. +            start = pos - x;
  6363. +            count = x + 1;
  6364. +            if (currcons != fg_console)
  6365. +              break;
  6366.              sw->con_clear(&vc_cons[currcons],y,0,1,x + 1);
  6367.              break;
  6368.          case 2: /* erase whole line */
  6369. +            start = pos - x;
  6370. +            count = video_num_columns;
  6371. +            if (currcons != fg_console)
  6372. +              break;
  6373.              sw->con_clear(&vc_cons[currcons],y,0,1,video_num_columns);
  6374.              break;
  6375.          default:
  6376.              return;
  6377.      }
  6378. +    while (count-- > 0)
  6379. +      *start++ = video_erase_char;
  6380.      need_wrap = 0;
  6381.  }
  6382.  
  6383. @@ -444,28 +516,39 @@
  6384.   * seems hardware independent, but uses the EGA/VGA way of representing
  6385.   * attributes. 
  6386.   * TODO: modify for 680x0 and add attribute processing to putc code.
  6387. + *
  6388. + * ++roman: I completely changed the attribute format for monochrome
  6389. + * mode (!can_do_color). The formerly used MDA (monochrome display
  6390. + * adapter) format didn't allow the combination of certain effects.
  6391. + * Now the attribute is just a bit vector:
  6392. + *  Bit 0..1: intensity (0..2)
  6393. + *  Bit 2   : underline
  6394. + *  Bit 3   : reverse
  6395. + *  Bit 7   : blink
  6396.   */
  6397.  static void update_attr(int currcons)
  6398.  {
  6399. +    if (!can_do_color) {
  6400. +        /* Special treatment for monochrome */
  6401. +        attr = intensity |
  6402. +            (underline ? 4 : 0) |
  6403. +            ((reverse ^ decscnm) ? 8 : 0) |
  6404. +            (blink ? 0x80 : 0);
  6405. +        video_erase_char = ' ' | ((reverse ^ decscnm) ? 0x800 : 0);
  6406. +        return;
  6407. +    }
  6408. +
  6409.      attr = color;
  6410. -    if (can_do_color) {
  6411.          if (underline)
  6412.              attr = (attr & 0xf0) | ulcolor;
  6413.          else if (intensity == 0)
  6414.              attr = (attr & 0xf0) | halfcolor;
  6415. -    }
  6416.      if (reverse ^ decscnm)
  6417.          attr = (attr & 0x88) | (((attr >> 4) | (attr << 4)) & 0x77);
  6418.      if (blink)
  6419.          attr ^= 0x80;
  6420.      if (intensity == 2)
  6421.          attr ^= 0x08;
  6422. -    if (!can_do_color) {
  6423. -        if (underline)
  6424. -            attr = (attr & 0xf8) | 0x01;
  6425. -        else if (intensity == 0)
  6426. -            attr = (attr & 0xf0) | 0x08;
  6427. -    }
  6428.      if (decscnm)
  6429.          video_erase_char = (((color & 0x88) | (((color >> 4) | (color << 4)) & 0x77)) << 8) | ' ';
  6430.      else
  6431. @@ -676,6 +759,17 @@
  6432.  
  6433.  static void insert_char(int currcons)
  6434.  {
  6435. +    int i;
  6436. +    unsigned short *p = pos;
  6437. +
  6438. +    for (i = video_num_columns - x - 2; i >= 0; i--)
  6439. +      p[i + 1] = p[i];
  6440. +    *pos = video_erase_char;
  6441. +    need_wrap = 0;
  6442. +
  6443. +    if (currcons != fg_console)
  6444. +      return;
  6445. +
  6446.      /* Arno:
  6447.       * Move the remainder of the line (-1 character) one spot to the right
  6448.       */
  6449. @@ -683,23 +777,34 @@
  6450.      /*
  6451.       * Print the erase char on the current position
  6452.       */
  6453. -    sw->con_putc(&vc_cons[currcons],(video_erase_char & 0x00ff),y,x,reverse ? DM_INVERSE : DM_COPY);
  6454. -
  6455. -    need_wrap = 0;
  6456. +    sw->con_putc(&vc_cons[currcons],(video_erase_char & 0x00ff),y,x);
  6457.  }
  6458.  
  6459.  static void csi_at(int currcons, unsigned int nr)
  6460.  {
  6461. +    int i;
  6462. +    unsigned short *p;
  6463. +
  6464.      if (nr > video_num_columns - x)
  6465.          nr = video_num_columns - x;
  6466.      else if (!nr)
  6467.          nr = 1;
  6468. +
  6469. +    p = pos + video_num_columns - x - nr;
  6470. +    while (--p >= pos)
  6471. +      p[nr] = *p;
  6472. +    for (i = 0; i < nr; i++)
  6473. +      *++p = video_erase_char;
  6474. +    need_wrap = 0;
  6475. +
  6476. +    if (currcons != fg_console)
  6477. +      return;
  6478. +
  6479.      sw->con_bmove (&vc_cons[currcons], y, x, y, x + nr,
  6480.                 1, video_num_columns - x - nr);
  6481.      while (nr--)
  6482.        sw->con_putc (&vc_cons[currcons], video_erase_char & 0x00ff,
  6483. -            y, x + nr, reverse ? DM_INVERSE : DM_COPY);
  6484. -    need_wrap = 0;
  6485. +            y, x + nr);
  6486.  }
  6487.  
  6488.  static void csi_L(int currcons, unsigned int nr)
  6489. @@ -714,20 +819,31 @@
  6490.  
  6491.  static void csi_P(int currcons, unsigned int nr)
  6492.  {
  6493. +    int i;
  6494. +    unsigned short *p, *end;
  6495. +
  6496.      if (nr > video_num_columns - x)
  6497.          nr = video_num_columns - x;
  6498.      else if (!nr)
  6499.          nr = 1;
  6500.  
  6501. +    p = pos;
  6502. +    end = pos + video_num_columns - x - nr;
  6503. +    while (p < end)
  6504. +      *p = p[nr], p++;
  6505. +    for (i = 0; i < nr; i++)
  6506. +      *p++ = video_erase_char;
  6507. +    need_wrap = 0;
  6508. +
  6509. +    if (currcons != fg_console)
  6510. +      return;
  6511. +
  6512.      sw->con_bmove (&vc_cons[currcons], y, x + nr, y, x,
  6513.                 1, video_num_columns - x - nr);
  6514.  
  6515.      while (nr--)
  6516.        sw->con_putc (&vc_cons[currcons], video_erase_char & 0x00ff,
  6517. -            y, video_num_columns - 1 - nr, reverse ? DM_INVERSE
  6518. -            : DM_COPY);
  6519. -
  6520. -    need_wrap = 0;
  6521. +            y, video_num_columns - 1 - nr);
  6522.  }
  6523.  
  6524.  static void csi_M(int currcons, unsigned int nr)
  6525. @@ -829,6 +945,11 @@
  6526.          printk("con_write: illegal tty (%d)\n", currcons);
  6527.          return;
  6528.      }
  6529. +
  6530. +    /* undraw cursor first */
  6531. +    if (currcons == fg_console)
  6532. +        hide_cursor(currcons);
  6533. +
  6534.  #ifdef CONFIG_SELECTION
  6535.      /* clear the selection as soon as any characters are to be written
  6536.         out on the console holding the selection. */
  6537. @@ -854,18 +975,22 @@
  6538.                           * P.S. I hate 8 spaces per tab! Use Emacs!
  6539.                          */
  6540.  
  6541. -                        if (!decim) { 
  6542. +            /* Only use this for the foreground console,
  6543. +                           where we really draw the chars */
  6544. +
  6545. +                        if (!decim && currcons == fg_console) { 
  6546.                              char   *p     = buf;
  6547.                              ushort count  = 1;
  6548.                              ushort nextx  = x + 1;
  6549.                              ushort cols   = video_num_columns;
  6550.                              
  6551. -                            *p++ = c;
  6552. +                            *p++ = translate[c];
  6553. +                *pos++ = translate[c] | (attr << 8);
  6554.  
  6555.                              if (nextx == cols) {
  6556.                                  sw->con_putc(&vc_cons[currcons],
  6557. -                                             *buf, y, x, reverse ? DM_INVERSE
  6558. -                         : DM_COPY);
  6559. +                                             *buf, y, x);
  6560. +                pos--;
  6561.                                  need_wrap = decawm;
  6562.                                  continue;
  6563.                              }
  6564. @@ -876,7 +1001,8 @@
  6565.                     (c=get_tty_queue(&tty->write_q)) >= 0 &&
  6566.                                     translate[c])
  6567.                  {
  6568. -                                *p++ = c;
  6569. +                                *p++ = translate[c];
  6570. +                *pos++ = translate[c] | (attr << 8);
  6571.                  ++count;
  6572.                  ++nextx;
  6573.                  if (nextx == cols || count == sizeof (buf))
  6574. @@ -884,9 +1010,9 @@
  6575.                  }
  6576.  
  6577.                              sw->con_putcs(&vc_cons[currcons],
  6578. -                                          buf, count, y, x, reverse ? DM_INVERSE
  6579. -                      : DM_COPY);
  6580. +                                          buf, count, y, x);
  6581.                              if (nextx == cols) {
  6582. +                    pos--;
  6583.                                  x         = cols-1;
  6584.                                  need_wrap = decawm;
  6585.                  continue;
  6586. @@ -907,17 +1033,19 @@
  6587.               * TODO: build VT100 charset and enable translation.
  6588.               */
  6589.  
  6590. -            /*c = translate[c];*/
  6591. +            c = translate[c];
  6592.  
  6593.              /* Arno:
  6594.               * 680x0: ignore attributes for now, just 
  6595.               * print character.
  6596.               */
  6597. -            sw->con_putc(&vc_cons[currcons],c,y,x,
  6598. -                     reverse ? DM_INVERSE : DM_COPY);
  6599. +            *pos = c | (attr << 8);
  6600. +            if (currcons == fg_console)
  6601. +              sw->con_putc(&vc_cons[currcons],c,y,x);
  6602.              if (x == video_num_columns - 1)
  6603.                  need_wrap = decawm;
  6604.              else {
  6605. +                pos++;
  6606.                  x++;
  6607.              }
  6608.              continue;
  6609. @@ -935,11 +1063,13 @@
  6610.                  bs(currcons);
  6611.                  continue;
  6612.              case 9:
  6613. +                pos -= x;
  6614.                  while (x < video_num_columns - 1) {
  6615.                      x++;
  6616.                      if (tab_stop[x >> 5] & (1 << (x & 31)))
  6617.                          break;
  6618.                  }
  6619. +                pos += x;
  6620.                  continue;
  6621.              case 10: case 11: case 12:
  6622.                  lf(currcons);
  6623. @@ -1242,6 +1372,10 @@
  6624.     if (!printable || currcons<0 || currcons>=NR_CONSOLES)
  6625.        return;
  6626.  
  6627. +    /* undraw cursor first */
  6628. +    if (currcons == fg_console)
  6629. +        hide_cursor(currcons);
  6630. +
  6631.     /* Contrived structure to try and emulate original need_wrap behaviour
  6632.      * Problems caused when we have need_wrap set on '\n' character */
  6633.     
  6634. @@ -1249,8 +1383,10 @@
  6635.         if (c == 10 || c == 13 || need_wrap) {
  6636.             if ((count = b - start - 1) > 0) {
  6637.                 sw->con_putcs(&vc_cons[currcons], start, count ,
  6638. -                             y, x, DM_COPY);
  6639. +                             y, x);
  6640.                 x += count;
  6641. +           if (need_wrap)
  6642. +         x--;
  6643.             }
  6644.  
  6645.             if (c != 13)
  6646. @@ -1264,16 +1400,18 @@
  6647.             start = b-1; myx = x;
  6648.         }
  6649.  
  6650. +       *pos = c | (attr << 8);
  6651.         if (myx == video_num_columns - 1) {
  6652.             need_wrap = 1;
  6653.             continue;
  6654.         }
  6655. +       pos++;
  6656.         myx++;
  6657.     }
  6658.  
  6659.     if ((count = b - start -1) > 0) {
  6660.         sw->con_putcs(&vc_cons[currcons], start, count ,
  6661. -                     y, x, DM_COPY);
  6662. +                     y, x);
  6663.         x += count;
  6664.         if (x == video_num_columns)
  6665.       {
  6666. @@ -1301,14 +1439,6 @@
  6667.      char *display_desc = "????";
  6668.      unsigned int currcons = 0;
  6669.  
  6670. -/* 
  6671. - * Arno:
  6672. - * We really should move this to sw->con_init or some other platform
  6673. - * specific init code instead of hard-coding this...
  6674. - */
  6675. -    display_desc="ECS";
  6676. -    can_do_color=1;
  6677. -
  6678.      sw=conswitchp;
  6679.      timer_table[BLANK_TIMER].fn = blank_screen;
  6680.      timer_table[BLANK_TIMER].expires = 0;
  6681. @@ -1316,17 +1446,7 @@
  6682.          timer_table[BLANK_TIMER].expires = jiffies+blankinterval;
  6683.          timer_active |= 1<<BLANK_TIMER;
  6684.      }
  6685. -    kmem_start = sw->con_init(&vc_cons[currcons], kmem_start);
  6686.  
  6687. -#if 0
  6688. -/* 
  6689. - * Arno:
  6690. - * Strange things happen when more than 1 console is inited... 
  6691. - * 
  6692. - * TODO: extend low-level code for multi-console support.
  6693. - * Question: how are we going to do VC's? Save/restore bitplanes/copperlists
  6694. - * etc.? Can get memory expensive with 4 bitplane screens (in the future..)
  6695. - */
  6696.      for (currcons = 0; currcons<NR_CONSOLES; currcons++) {
  6697.          vcmode        = KD_TEXT;
  6698.          vtmode.mode    = VT_AUTO;
  6699. @@ -1337,22 +1457,20 @@
  6700.          vtpid        = -1;
  6701.          vtnewvt        = -1;
  6702.          clr_kbd(kbdraw);
  6703. +        sw = conswitchp;
  6704. +        can_do_color = 1;
  6705. +        kmem_start = sw->con_init(&vc_cons[currcons], kmem_start, &display_desc);
  6706. +        video_size_row = video_num_columns * 2;
  6707. +        pos = video_mem_start = (unsigned short *) kmem_start;
  6708. +        kmem_start += video_num_columns * video_num_lines * 2;
  6709.          def_color    = 0x07;   /* white */
  6710.          ulcolor        = 0x0f;   /* bold white */
  6711.          halfcolor    = 0x08;   /* grey */
  6712. -        reset_terminal(currcons, currcons);
  6713. -
  6714. -
  6715. +        reset_terminal(currcons, 1);
  6716.      }
  6717. -#endif
  6718. -
  6719.  
  6720. +    vcmode = KD_TEXT;
  6721.      currcons = fg_console = 0;
  6722. -    def_color    = 0x07;   /* white */
  6723. -    ulcolor        = 0x0f;   /* bold white */
  6724. -    halfcolor    = 0x08;   /* grey */
  6725. -    reset_terminal(currcons, currcons);
  6726. -
  6727.      gotoxy(currcons,0,0);
  6728.      save_cur(currcons);
  6729.      gotoxy(currcons,0,0);
  6730. @@ -1365,7 +1483,7 @@
  6731.      register_console(console_print);
  6732.  
  6733.      printk("Console: %s %s %ldx%ld, %d virtual consoles\n",
  6734. -        can_do_color?"colour":"mono",
  6735. +        can_do_color ? "colour":"mono",
  6736.          display_desc,
  6737.          video_num_columns,video_num_lines,
  6738.          NR_CONSOLES);
  6739. @@ -1400,54 +1518,87 @@
  6740.          timer_active |= 1<<BLANK_TIMER;
  6741.      }
  6742.      console_blanked = 0;
  6743. -        (vc_cons[fg_console].vc_sw)->con_blank (0);
  6744. +    if ((vc_cons[fg_console].vc_sw)->con_blank (0))
  6745. +        /* Low-level driver cannot restore -> do it ourselves */
  6746. +          update_screen( fg_console );
  6747. +    set_cursor (fg_console);
  6748.  }
  6749.  
  6750.  void update_screen(int new_console)
  6751.  {
  6752. +    int currcons = fg_console;
  6753. +    int xx, yy, startx, attr_save;
  6754. +    char buf[256], *bufp;
  6755. +    unsigned short *p;
  6756.      static int lock = 0;
  6757.  
  6758. -    if (new_console == fg_console || lock)
  6759. -        return;
  6760. +    if (/* new_console == fg_console || */ lock)
  6761.      return;
  6762.      lock = 1;
  6763. -    fg_console = new_console;
  6764.      kbdsave(new_console);
  6765. -#if 0
  6766. -    get_scrmem(fg_console); 
  6767. -    set_scrmem(fg_console); 
  6768. -    set_origin(fg_console);
  6769. -    set_cursor(new_console);
  6770. +    sw->con_cursor (&vc_cons[currcons], CM_ERASE);
  6771. +    sw->con_switch (&vc_cons[new_console]);
  6772. +    currcons = fg_console = new_console;
  6773. +    /* Update the screen contents */
  6774. +    p = video_mem_start;
  6775. +    attr_save = attr;
  6776. +    for (yy = 0; yy < video_num_lines; yy++)
  6777. +      {
  6778. +        bufp = buf;
  6779. +        for (startx = xx = 0; xx < video_num_columns; xx++)
  6780. +          {
  6781. +        if (attr != (*p >> 8) & 0xff)
  6782. +          {
  6783. +            if (bufp > buf)
  6784. +              sw->con_putcs (&vc_cons[currcons], buf, bufp - buf,
  6785. +                     yy, startx);
  6786. +            startx = xx;
  6787. +            bufp = buf;
  6788. +            attr = (*p >> 8) & 0xff;
  6789. +          }
  6790. +        *bufp++ = *p++;
  6791. +        if (bufp == buf + sizeof (buf))
  6792. +          {
  6793. +            sw->con_putcs (&vc_cons[currcons], buf, bufp - buf,
  6794. +                   yy, startx);
  6795. +            startx = xx + 1;
  6796. +            bufp = buf;
  6797. +          }
  6798. +          }
  6799. +        if (bufp > buf)
  6800. +          sw->con_putcs (&vc_cons[currcons], buf, bufp - buf,
  6801. +                 yy, startx);
  6802. +      }
  6803. +    set_cursor (currcons);
  6804. +    attr = attr_save;
  6805.      set_leds();
  6806.      compute_shiftstate();
  6807. -#endif
  6808.      lock = 0;
  6809.  }
  6810.  
  6811.  int do_screendump(int arg)
  6812.  {
  6813. -#if 0
  6814.      char *sptr, *buf = (char *)arg;
  6815.      int currcons, l;
  6816.  
  6817.      if (!suser())
  6818.          return -EPERM;
  6819. -    l = verify_area(VERIFY_WRITE, buf,2+video_num_columns*video_num_lines);
  6820. +    l = verify_area(VERIFY_READ, buf,2);
  6821.      if (l)
  6822.          return l;
  6823.      currcons = get_fs_byte(buf+1);
  6824.      if ((currcons<0) || (currcons>NR_CONSOLES))
  6825.          return -EIO;
  6826. +    currcons = (currcons ? currcons-1 : fg_console);
  6827. +    l = verify_area(VERIFY_WRITE, buf,2+video_num_columns*video_num_lines);
  6828. +    if (l)
  6829. +        return l;
  6830.      put_fs_byte((char)(video_num_lines),buf++);    
  6831.      put_fs_byte((char)(video_num_columns),buf++);
  6832. -    currcons = (currcons ? currcons-1 : fg_console);
  6833. -    sptr = (char *) origin;
  6834. +    sptr = (char *) video_mem_start;
  6835.      for (l=video_num_lines*video_num_columns; l>0 ; l--, sptr++)
  6836.          put_fs_byte(*sptr++,buf++);    
  6837.      return(0);
  6838. -#else
  6839. -        return -EOPNOTSUPP;
  6840. -#endif
  6841.  }
  6842.  
  6843.  /*
  6844. @@ -1468,24 +1619,45 @@
  6845.  }
  6846.  
  6847.  #ifdef CONFIG_SELECTION
  6848. -/* correction factor for when screen is hardware-scrolled */
  6849. -#define    hwscroll_offset (currcons == fg_console ? ((__real_origin - __origin) << 1) : 0)
  6850.  
  6851.  /* set reverse video on characters s-e of console with selection. */
  6852.  static void highlight(const int currcons, const int s, const int e)
  6853.  {
  6854. -    unsigned char *p, *p1, *p2;
  6855. +    int xpos, ypos, k, start, end;
  6856. +    int oldattr, chattr;
  6857. +    unsigned short *p;
  6858.  
  6859. -    p1 = (unsigned char *)origin - hwscroll_offset + s + 1;
  6860. -    p2 = (unsigned char *)origin - hwscroll_offset + e + 1;
  6861. -    if (p1 > p2)
  6862. +    if (s < e)
  6863.      {
  6864. -        p = p1;
  6865. -        p1 = p2;
  6866. -        p2 = p;
  6867. +        start = s >> 1;
  6868. +        end = e >> 1;
  6869.      }
  6870. -    for (p = p1; p <= p2; p += 2)
  6871. -        *p = (*p & 0x88) | ((*p << 4) & 0x70) | ((*p >> 4) & 0x07);
  6872. +    else
  6873. +    {
  6874. +        start = e >> 1;
  6875. +        end = s >> 1;
  6876. +    }
  6877. +    oldattr = attr;
  6878. +
  6879. +    for (k = start; k <= end; k++)
  6880. +    {
  6881. +        ypos = k / video_num_columns;
  6882. +        xpos = k - (ypos * video_num_columns);
  6883. +        p = video_mem_start + k;
  6884. +        chattr = (*p >> 8) & 0xff;
  6885. +
  6886. +        if (can_do_color)
  6887. +          attr = ((chattr << 4) & 0x70) | ((chattr >> 4) & 0x07);
  6888. +        else
  6889. +          attr = chattr | 8;
  6890. +          
  6891. +        /* invert the character on screen */
  6892. +        sw->con_putc(&vc_cons[currcons], *p & 0xff, ypos, xpos);
  6893. +        /* dunno if this might break with VCs - directly modifying the VC buffers */
  6894. +        /* write the (inverted) character into the VC buffer also */
  6895. +        *p = ((*p & 0xff) | (attr << 8));
  6896. +    }
  6897. +    attr = oldattr;
  6898.  }
  6899.  
  6900.  /* is c in range [a-zA-Z0-9_]? */
  6901. @@ -1494,6 +1666,7 @@
  6902.  /* does screen address p correspond to character at LH/RH edge of screen? */
  6903.  static inline int atedge(const int p)
  6904.  {
  6905. +    int currcons = fg_console;
  6906.      return (!(p % video_size_row) || !((p + 2) % video_size_row));
  6907.  }
  6908.  
  6909. @@ -1511,7 +1684,12 @@
  6910.      int sel_mode, new_sel_start, new_sel_end, spc;
  6911.      char *bp, *obp, *spos;
  6912.      int i, ps, pe;
  6913. -    char *off = (char *)origin - hwscroll_offset;
  6914. +
  6915. +    /* 
  6916. +        off is video_mem_start + 1 because the lower byte of a short in 
  6917. +        the buffer contains the character 
  6918. +    */
  6919. +    char *off = (char *)video_mem_start + 1;
  6920.  
  6921.      unblank_screen();
  6922.      args = (unsigned short *)(arg + 1);
  6923. diff -ubr -x RCS -x *.[ao] -x .depend -x .version -x .config -x System.map -x vmlinux -x bootstrap -x *~ -x config.old -x *.orig -x *.rej -x *# -x version.h -x autoconf.h --new-file linux-0.9pl3/drivers/char/lp.c linux-0.9pl4/drivers/char/lp.c
  6924. --- linux-0.9pl3/drivers/char/lp.c    Sun Aug 14 10:30:39 1994
  6925. +++ linux-0.9pl4/drivers/char/lp.c    Thu Nov 24 21:01:35 1994
  6926. @@ -138,7 +138,7 @@
  6927.  static int lp_write_interrupt(struct inode * inode, struct file * file, char * buf, int count)
  6928.  #endif
  6929.  {
  6930. -    static unsigned long total_bytes_written = 0;
  6931. +    unsigned long total_bytes_written = 0;
  6932.  
  6933.      do {
  6934.          bytes_written = 0;
  6935. diff -ubr -x RCS -x *.[ao] -x .depend -x .version -x .config -x System.map -x vmlinux -x bootstrap -x *~ -x config.old -x *.orig -x *.rej -x *# -x version.h -x autoconf.h --new-file linux-0.9pl3/drivers/char/mem.c linux-0.9pl4/drivers/char/mem.c
  6936. --- linux-0.9pl3/drivers/char/mem.c    Tue Sep 27 22:24:36 1994
  6937. +++ linux-0.9pl4/drivers/char/mem.c    Sun Oct 23 15:34:29 1994
  6938. @@ -94,12 +94,13 @@
  6939.  {
  6940.      struct vm_area_struct * mpnt;
  6941.  
  6942. -    if (off & 0xfff || off + len < off)
  6943. +    if ((off & 0xfff) || off + len < off)
  6944.          return -ENXIO;
  6945.  #ifdef __i386__
  6946.      if (x86 > 3 && off >= high_memory)
  6947.          prot |= PAGE_PCD;
  6948.  #endif
  6949. +
  6950.      if (remap_page_range(addr, off, len, prot))
  6951.          return -EAGAIN;
  6952.  /* try to create a dummy vmm-structure so that the rest of the kernel knows we are here */
  6953. diff -ubr -x RCS -x *.[ao] -x .depend -x .version -x .config -x System.map -x vmlinux -x bootstrap -x *~ -x config.old -x *.orig -x *.rej -x *# -x version.h -x autoconf.h --new-file linux-0.9pl3/drivers/char/serial.c linux-0.9pl4/drivers/char/serial.c
  6954. --- linux-0.9pl3/drivers/char/serial.c    Mon Sep 19 21:39:39 1994
  6955. +++ linux-0.9pl4/drivers/char/serial.c    Mon Nov 21 18:09:04 1994
  6956. @@ -215,7 +215,7 @@
  6957.      save_flags(flags); cli();
  6958.  
  6959.  #ifdef SERIAL_DEBUG_OPEN
  6960. -    printk("starting up ttyS%d ...", info->line);
  6961. +    printk("starting up ttyS%d\n", info->line);
  6962.  #endif
  6963.  
  6964.      info->sw->init( info );
  6965. @@ -247,7 +247,7 @@
  6966.          return;
  6967.  
  6968.  #ifdef SERIAL_DEBUG_OPEN
  6969. -    printk("Shutting down serial port %d ....", info->line);
  6970. +    printk("Shutting down serial port %d\n", info->line);
  6971.  #endif
  6972.      
  6973.      save_flags(flags); cli(); /* Disable interrupts */
  6974. @@ -873,7 +873,7 @@
  6975.      info->pgrp = current->pgrp;
  6976.  
  6977.  #ifdef SERIAL_DEBUG_OPEN
  6978. -    printk("rs_open ttyS%d successfull...", info->line);
  6979. +    printk("rs_open ttyS%d successfull\n", info->line);
  6980.  #endif
  6981.      return 0;
  6982.  }
  6983. diff -ubr -x RCS -x *.[ao] -x .depend -x .version -x .config -x System.map -x vmlinux -x bootstrap -x *~ -x config.old -x *.orig -x *.rej -x *# -x version.h -x autoconf.h --new-file linux-0.9pl3/drivers/char/tty_io.c linux-0.9pl4/drivers/char/tty_io.c
  6984. --- linux-0.9pl3/drivers/char/tty_io.c    Mon Sep 19 21:29:37 1994
  6985. +++ linux-0.9pl4/drivers/char/tty_io.c    Thu Oct 20 22:54:22 1994
  6986. @@ -778,7 +778,9 @@
  6987.              }
  6988.              if (tty->char_error == TTY_OVERRUN) {
  6989.                  tty->char_error = 0;
  6990. +#if 0 /* XXX */
  6991.                  printk("tty%d: input overrun\n", tty->line);
  6992. +#endif
  6993.                  continue;
  6994.              }
  6995.              /* Must be a parity or frame error */
  6996. diff -ubr -x RCS -x *.[ao] -x .depend -x .version -x .config -x System.map -x vmlinux -x bootstrap -x *~ -x config.old -x *.orig -x *.rej -x *# -x version.h -x autoconf.h --new-file linux-0.9pl3/drivers/net/slip.c linux-0.9pl4/drivers/net/slip.c
  6997. --- linux-0.9pl3/drivers/net/slip.c    Sun Mar 13 08:47:58 1994
  6998. +++ linux-0.9pl4/drivers/net/slip.c    Mon Oct 10 16:47:47 1994
  6999. @@ -1102,9 +1102,9 @@
  7000.    DPRINTF((DBG_SLIP, "SLIP: ioctl(%d, 0x%X, 0x%X)\n", tty->line, cmd, arg));
  7001.    switch(cmd) {
  7002.      case SIOCGIFNAME:
  7003. -        err=verify_area(VERIFY_WRITE, arg, 16);
  7004. +        err=verify_area(VERIFY_WRITE, arg, strlen(sl->dev->name) + 1);
  7005.          if(err)
  7006. -            return -err;
  7007. +            return err;
  7008.          memcpy_tofs(arg, sl->dev->name, strlen(sl->dev->name) + 1);
  7009.          return(0);
  7010.      case SIOCGIFENCAP:
  7011. diff -ubr -x RCS -x *.[ao] -x .depend -x .version -x .config -x System.map -x vmlinux -x bootstrap -x *~ -x config.old -x *.orig -x *.rej -x *# -x version.h -x autoconf.h --new-file linux-0.9pl3/drivers/scsi/Makefile linux-0.9pl4/drivers/scsi/Makefile
  7012. --- linux-0.9pl3/drivers/scsi/Makefile    Sun Aug 14 10:30:46 1994
  7013. +++ linux-0.9pl4/drivers/scsi/Makefile    Mon Nov  7 22:25:08 1994
  7014. @@ -82,8 +82,8 @@
  7015.  endif
  7016.  
  7017.  ifdef CONFIG_ATARI_SCSI
  7018. -SCSI_OBJS := $(SCSI_OBJS) atari_sc.o
  7019. -SCSI_SRCS := $(SCSI_SRCS) atari_sc.c
  7020. +SCSI_OBJS := $(SCSI_OBJS) atari_scsi.o
  7021. +SCSI_SRCS := $(SCSI_SRCS) atari_scsi.c
  7022.  endif
  7023.    
  7024.  scsi.a: $(SCSI_OBJS)
  7025. diff -ubr -x RCS -x *.[ao] -x .depend -x .version -x .config -x System.map -x vmlinux -x bootstrap -x *~ -x config.old -x *.orig -x *.rej -x *# -x version.h -x autoconf.h --new-file linux-0.9pl3/drivers/scsi/atari_NCR5380.c linux-0.9pl4/drivers/scsi/atari_NCR5380.c
  7026. --- linux-0.9pl3/drivers/scsi/atari_NCR5380.c    Tue Sep 27 22:22:09 1994
  7027. +++ linux-0.9pl4/drivers/scsi/atari_NCR5380.c    Thu Nov 24 21:09:40 1994
  7028. @@ -59,7 +59,10 @@
  7029.  
  7030.  
  7031.  /*
  7032. - * $Log: NCR5380.c,v $
  7033. + * $Log: atari_NCR5380.c,v $
  7034. + * Revision 1.1  1994/11/08  03:25:43  hamish
  7035. + * Initial revision
  7036. + *
  7037.   * Revision 1.5  1994/01/19  09:14:57  drew
  7038.   * Fixed udelay() hack that was being used on DATAOUT phases
  7039.   * instead of a propper wait for the final handshake.
  7040. @@ -837,6 +840,7 @@
  7041.      NCR5380_all_init();
  7042.  
  7043.      hostdata->id_mask = 1 << instance->this_id;
  7044. +    hostdata->id_higher_mask = 0;
  7045.      for (i = hostdata->id_mask; i <= 0x80; i <<= 1)
  7046.      if (i > hostdata->id_mask)
  7047.          hostdata->id_higher_mask |= i;
  7048. @@ -1003,7 +1007,7 @@
  7049.           */
  7050.          for (tmp = (Scsi_Cmnd *) hostdata->issue_queue, 
  7051.              prev = NULL; tmp; prev = tmp, tmp = (Scsi_Cmnd *) 
  7052. -            tmp->host_scribble) 
  7053. +            tmp->host_scribble) {
  7054.  
  7055.              /*  When we find one, remove it from the issue queue. */
  7056.              if (!(hostdata->busy[tmp->target] & (1 << tmp->lun))) {
  7057. @@ -1044,12 +1048,15 @@
  7058.                  hostdata->issue_queue;
  7059.                  hostdata->issue_queue = tmp;
  7060.                  sti();
  7061. +                if (hostdata->connected)
  7062. +                break;
  7063.  #if (NDEBUG & (NDEBUG_MAIN | NDEBUG_QUEUES))
  7064.              printk("scsi%d : main(): select() failed, returned to issue_queue\n",
  7065.                  instance->host_no);
  7066.  #endif
  7067.              }
  7068.              } /* if target/lun is not busy */
  7069. +        }
  7070.          } /* if (!hostdata->connected) */
  7071.          
  7072.          if (hostdata->connected 
  7073. @@ -1373,6 +1380,11 @@
  7074.       * data bus during SELECTION.
  7075.       */
  7076.  
  7077. +    cli();
  7078. +    if (hostdata->connected) {
  7079. +    sti();
  7080. +    return -1;
  7081. +    }
  7082.      NCR5380_write(TARGET_COMMAND_REG, 0);
  7083.  
  7084.      /* Start arbitration */ 
  7085. @@ -1382,6 +1394,7 @@
  7086.      /* Wait for arbitration logic to complete */
  7087.      while (!(NCR5380_read(INITIATOR_COMMAND_REG) & ICR_ARBITRATION_PROGRESS));
  7088.  
  7089. +    sti();
  7090.  #if (NDEBUG & NDEBUG_ARBITRATION) 
  7091.      printk("scsi%d : arbitration complete\n", instance->host_no);
  7092.  /* Avoid GCC 2.4.5 asm needs to many reloads error */
  7093. @@ -1400,7 +1413,8 @@
  7094.      /* Check for lost arbitration */
  7095.      if ((NCR5380_read(INITIATOR_COMMAND_REG) & ICR_ARBITRATION_LOST) ||
  7096.      (NCR5380_read(CURRENT_SCSI_DATA_REG) & hostdata->id_higher_mask) ||
  7097. -    (NCR5380_read(INITIATOR_COMMAND_REG) & ICR_ARBITRATION_LOST)) {
  7098. +    (NCR5380_read(INITIATOR_COMMAND_REG) & ICR_ARBITRATION_LOST) ||
  7099. +    hostdata->connected) {
  7100.      NCR5380_write(MODE_REG, MR_BASE); 
  7101.  #if (NDEBUG & NDEBUG_ARBITRATION)
  7102.      printk("scsi%d : lost arbitration, deasserting MR_ARBITRATE\n", 
  7103. @@ -1428,6 +1442,12 @@
  7104.  
  7105.      udelay(2);    
  7106.  
  7107. +    if (hostdata->connected) {
  7108. +    NCR5380_write(MODE_REG, MR_BASE);
  7109. +    NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
  7110. +    return -1;
  7111. +    }
  7112. +
  7113.  #if (NDEBUG & NDEBUG_ARBITRATION)
  7114.      printk("scsi%d : won arbitration\n", instance->host_no);
  7115.  #endif
  7116. @@ -1453,6 +1473,12 @@
  7117.       * Reselect interrupts must be turned off prior to the dropping of BSY,
  7118.       * otherwise we will trigger an interrupt.
  7119.       */
  7120. +
  7121. +    if (hostdata->connected) {
  7122. +    NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
  7123. +    return -1;
  7124. +    }
  7125. +
  7126.      NCR5380_write(SELECT_ENABLE_REG, 0);
  7127.  
  7128.      /* Reset BSY */
  7129. @@ -1764,9 +1790,6 @@
  7130.      instance->host_no, instance->dma_channel, (p & SR_IO) ? "reading" :
  7131.      "writing", c, (p & SR_IO) ? "to" : "from", (unsigned) d);
  7132.  #endif
  7133. -    hostdata->dma_len = (p & SR_IO) ?
  7134. -    NCR5380_dma_read_setup(instance, d, c) : 
  7135. -    NCR5380_dma_write_setup(instance, d, c);
  7136.  #endif
  7137.  
  7138.      NCR5380_write(TARGET_COMMAND_REG, PHASE_SR_TO_TCR(p));
  7139. @@ -1798,6 +1821,13 @@
  7140.      NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_DATA);
  7141.      NCR5380_write(START_DMA_SEND_REG, 0);
  7142.      }
  7143. +#if defined(REAL_DMA) || defined(REAL_DMA_POLL) 
  7144. +    cli();
  7145. +    hostdata->dma_len = (p & SR_IO) ?
  7146. +    NCR5380_dma_read_setup(instance, d, c) : 
  7147. +    NCR5380_dma_write_setup(instance, d, c);
  7148. +    sti();
  7149. +#endif
  7150.  
  7151.  #if defined(REAL_DMA_POLL)
  7152.      do {
  7153. @@ -2084,19 +2114,13 @@
  7154.  /* ++roman: I suggest, this should be
  7155.   *   #if def(REAL_DMA) || def(PSEUDO_DMA) || ...
  7156.   * instead of leaving REAL_DMA out.
  7157. - *
  7158. - * GK: this does not work on FALCON:
  7159. - *   #if def(REAL_DMA) || def(PSEUDO_DMA) || ... 
  7160. - *       ^^^^^^^^^^^^^^^^
  7161. - *   results in timeout during partition check --> timeout in abort -->
  7162. - *   timeout in reset --> kernel panic
  7163.   */
  7164.  
  7165.          CHECK_ICNT("starting transf in inform_transf");
  7166. -#if /*defined(REAL_DMA) ||*/ defined(PSEUDO_DMA) || defined(REAL_DMA_POLL)
  7167. +#if defined(REAL_DMA) || defined(PSEUDO_DMA) || defined(REAL_DMA_POLL)
  7168.  #ifdef NCR5380_dma_xfer_len
  7169.          if (!scsi_devices[cmd->index].borken &&
  7170. -            (transfersize = NCR5380_dma_xfer_len(instance, cmd)) > 7) {
  7171. +            (transfersize = NCR5380_dma_xfer_len(instance, cmd)) > 31) {
  7172.  #else
  7173.          if (!scsi_devices[cmd->index].borken && 
  7174.              (transfersize = cmd->transfersize) && 
  7175. @@ -2144,6 +2168,7 @@
  7176.           */
  7177.          len = 1;
  7178.          data = &tmp;
  7179. +        NCR5380_write(SELECT_ENABLE_REG, 0);     /* disable reselects */
  7180.          NCR5380_transfer_pio(instance, &phase, &len, &data);
  7181.          cmd->SCp.Message = tmp;
  7182.  
  7183. @@ -2165,6 +2190,8 @@
  7184.              printk("scsi%d : target %d lun %d linked command complete.\n",
  7185.              instance->host_no, cmd->target, cmd->lun);
  7186.  #endif
  7187. +            /* Enable reselect interupts */
  7188. +            NCR5380_write(SELECT_ENABLE_REG, hostdata->id_mask);
  7189.              /* 
  7190.               * Sanity check : A linked command should only terminate with
  7191.               * one of these messages if there are more linked commands
  7192. @@ -2200,6 +2227,8 @@
  7193.              instance->host_no, cmd->target, cmd->lun);
  7194.  #endif
  7195.              hostdata->busy[cmd->target] &= ~(1 << cmd->lun);
  7196. +            /* Enable reselect interupts */
  7197. +            NCR5380_write(SELECT_ENABLE_REG, hostdata->id_mask);
  7198.  
  7199.              /* ++roman: For Falcon SCSI, release the lock an on the
  7200.               * ST-DMA here if no other commands are waiting on the
  7201. @@ -2282,6 +2311,8 @@
  7202.              !hostdata->connected);
  7203.              return;
  7204.          case MESSAGE_REJECT:
  7205. +            /* Enable reselect interupts */
  7206. +            NCR5380_write(SELECT_ENABLE_REG, hostdata->id_mask);
  7207.              switch (hostdata->last_message) {
  7208.              case HEAD_OF_QUEUE_TAG:
  7209.              case ORDERED_QUEUE_TAG:
  7210. @@ -2293,8 +2324,8 @@
  7211.              break;
  7212.              }
  7213.          case DISCONNECT:
  7214. -            scsi_devices[cmd->index].disconnect = 1;
  7215.              cli();
  7216. +            scsi_devices[cmd->index].disconnect = 1;
  7217.              cmd->host_scribble = (unsigned char *) 
  7218.              hostdata->disconnected_queue;
  7219.              hostdata->connected = NULL;
  7220. @@ -2324,8 +2355,12 @@
  7221.           */
  7222.          case SAVE_POINTERS:
  7223.          case RESTORE_POINTERS:
  7224. +            /* Enable reselect interupts */
  7225. +            NCR5380_write(SELECT_ENABLE_REG, hostdata->id_mask);
  7226.              break;
  7227.          default:
  7228. +            /* Enable reselect interupts */
  7229. +            NCR5380_write(SELECT_ENABLE_REG, hostdata->id_mask);
  7230.  /* 
  7231.   * XXX rejected messages should be handled in the pio data transfer phase,
  7232.   * since ATN should be raised before ACK goes false when we reject a message
  7233. diff -ubr -x RCS -x *.[ao] -x .depend -x .version -x .config -x System.map -x vmlinux -x bootstrap -x *~ -x config.old -x *.orig -x *.rej -x *# -x version.h -x autoconf.h --new-file linux-0.9pl3/drivers/scsi/atari_sc.c linux-0.9pl4/drivers/scsi/atari_sc.c
  7234. --- linux-0.9pl3/drivers/scsi/atari_sc.c    Sun Aug 14 10:30:50 1994
  7235. +++ linux-0.9pl4/drivers/scsi/atari_sc.c    Wed Dec 31 19:00:00 1969
  7236. @@ -1,763 +0,0 @@
  7237. -/*
  7238. - * atari_scsi.c -- Device dependant functions for the Atari generic SCSI port
  7239. - *
  7240. - * Copyright 1994 Roman Hodek
  7241. - *   EMail: rnhodek@cip.informatik.uni-erlangen.de (Internet)
  7242. - *      or: Roman_Hodek@n.maus.de (MausNet, NO mail > 16 KB!)
  7243. - *
  7244. - *   Loosely based on the work of Robert De Vries' team and added:
  7245. - *    - working real DMA
  7246. - *    - Falcon support (untested yet!)   ++bjoern fixed and now it works
  7247. - *    - lots of extensions and bug fixes.
  7248. - *
  7249. - * This file is subject to the terms and conditions of the GNU General Public
  7250. - * License.  See the file README.legal in the main directory of this archive
  7251. - * for more details.
  7252. - *
  7253. - */
  7254. -
  7255. -
  7256. -/**************************************************************************/
  7257. -/*                                                                        */
  7258. -/* Notes for Falcon SCSI:                                                 */
  7259. -/* ----------------------                                                 */
  7260. -/*                                                                        */
  7261. -/* Since the Falcon SCSI uses the ST-DMA chip, that is shared among       */
  7262. -/* several device drivers, locking and unlocking the access to this       */
  7263. -/* chip is required. But locking is not possible from an interrupt,       */
  7264. -/* since it puts the process to sleep if the lock is not available.       */
  7265. -/* This prevents "late" locking of the DMA chip, i.e. locking it just     */
  7266. -/* before using it, since in case of disconnection-reconnection           */
  7267. -/* commands, the DMA is started from the reselection interrupt.           */
  7268. -/*                                                                        */
  7269. -/* Two possible schemes for ST-DMA-locking would be:                      */
  7270. -/*  1) The lock is taken for each command separately and disconnecting    */
  7271. -/*     is forbidden (i.e. can_queue = 1).                                 */
  7272. -/*  2) The DMA chip is locked when the first command comes in and         */
  7273. -/*     released when the last command is finished and all queues are      */
  7274. -/*     empty.                                                             */
  7275. -/* The first alternative would result in bad performance, since the       */
  7276. -/* interleaving of commands would not be used. The second is unfair to    */
  7277. -/* other drivers using the ST-DMA, because the queues will seldom be      */
  7278. -/* totally empty if there is a lot of disk traffic.                       */
  7279. -/*                                                                        */
  7280. -/* For this reasons I decided to employ a more elaborate scheme:          */
  7281. -/*  - First, we give up the lock everytime we can (for fairness), this    */
  7282. -/*    means every time a command finishes and there are no other commands */
  7283. -/*    on the disconnected queue.                                          */
  7284. -/*  - If there are others waiting to lock the DMA chip, we stop           */
  7285. -/*    issueing commands, i.e. moving them onto the issue queue.           */
  7286. -/*    Because of that, the disconnected queue will run empty in a         */
  7287. -/*    while. Instead we go to sleep on a 'fairness_queue'.                */
  7288. -/*  - If the lock is released, all processes waiting on the fairness      */
  7289. -/*    queue will be woken. The first of them trys to re-lock the DMA,     */
  7290. -/*    the others wait for the first to finish this task. After that,      */
  7291. -/*    they can all run on and do their commands...                        */
  7292. -/* This sounds complicated (and it is it :-(), but it seems to be a       */
  7293. -/* good compromise between fairness and performance: As long as noone     */
  7294. -/* else wants to work with the ST-DMA chip, SCSI can go along as          */
  7295. -/* usual. If now someone else comes, this behaviour is changed to a       */
  7296. -/* "fairness mode": just already initiated commands are finished and      */
  7297. -/* then the lock is released. The other one waiting will probably win     */
  7298. -/* the race for locking the DMA, since it was waiting for longer. And     */
  7299. -/* after it has finished, SCSI can go ahead again. Finally: I hope I      */
  7300. -/* have not produced any deadlock possibilites!                           */
  7301. -/*                                                                        */
  7302. -/**************************************************************************/
  7303. -
  7304. -
  7305. -
  7306. -#include <linux/config.h>
  7307. -
  7308. -#ifdef CONFIG_ATARI_SCSI
  7309. -
  7310. -/* #define NDEBUG (NDEBUG_DMA) */
  7311. -
  7312. -#define AUTOSENSE
  7313. -/* For the Atari version, use only polled IO or REAL_DMA */
  7314. -#define    REAL_DMA
  7315. -
  7316. -#if I_HAVE_OVERRUNS == 1 || I_HAVE_OVERRUNS == 2
  7317. -#define    READ_OVERRUNS
  7318. -#endif
  7319. -
  7320. -#include <linux/types.h>
  7321. -#include <linux/stddef.h>
  7322. -#include <linux/interrupt.h>
  7323. -#include <linux/bootinfo.h>
  7324. -#include <linux/atarihw.h>
  7325. -#include <linux/atariints.h>
  7326. -#include "../block/blk.h"
  7327. -#include "scsi.h"
  7328. -#include "hosts.h"
  7329. -#include "atari_scsi.h"
  7330. -#include "NCR5380.h"
  7331. -#include "constants.h"
  7332. -#include <linux/atari_stdma.h>
  7333. -
  7334. -
  7335. -#define    IS_A_TT()    (boot_info.bi_atari.model == ATARI_TT)
  7336. -
  7337. -#define    SCSI_DMA_WRITE_P(elt,val)                                    \
  7338. -    __asm__ __volatile__ ( "movepl %0,%1@(0)" : : "d" (val),        \
  7339. -                               "a" (&tt_scsi_dma.elt) );
  7340. -
  7341. -#define    SCSI_DMA_READ_P(elt) ({                                            \
  7342. -    unsigned long __val;                                                \
  7343. -    __asm__ __volatile__ ( "movepl %1@(0),%0"                            \
  7344. -                           : "=d" (__val) : "a" (&tt_scsi_dma.elt));    \
  7345. -    __val; })
  7346. -
  7347. -#define    SCSI_DMA_SETADR(adr)                    \
  7348. -    do {                                        \
  7349. -        unsigned long __adr = (adr);            \
  7350. -        st_dma.dma_lo = (unsigned char)__adr;    \
  7351. -        __adr >>= 8;                            \
  7352. -        st_dma.dma_md = (unsigned char)__adr;    \
  7353. -        __adr >>= 8;                            \
  7354. -        st_dma.dma_hi = (unsigned char)__adr;    \
  7355. -    } while(0)
  7356. -
  7357. -#define    SCSI_DMA_GETADR() ({                    \
  7358. -    unsigned long    __adr;                        \
  7359. -    __adr = st_dma.dma_lo;                        \
  7360. -    __asm__ __volatile__ ("nop");                \
  7361. -    __adr |= (st_dma.dma_md & 0xff) << 8;        \
  7362. -    __adr |= (st_dma.dma_hi & 0xff) << 16;        \
  7363. -    __adr;                                        \
  7364. -})
  7365. -
  7366. -
  7367. -
  7368. -/***************************** Prototypes *****************************/
  7369. -
  7370. -static void scsi_dma_buserr( struct intframe *fp, void *data);
  7371. -static void scsi_tt_intr( struct intframe *fp, void *data);
  7372. -static void scsi_falcon_intr( struct intframe *fp, void *data);
  7373. -static void atari_scsi_fetch_restbytes( void );
  7374. -static void falcon_release_lock_if_possible( struct NCR5380_hostdata *
  7375. -                                             hostdata );
  7376. -static void falcon_get_lock( void );
  7377. -static long atari_scsi_dma_residual( struct Scsi_Host *instance );
  7378. -static unsigned long atari_dma_xfer_len( unsigned long wanted_len );
  7379. -static unsigned char atari_scsi_tt_reg_read( unsigned char reg );
  7380. -static void atari_scsi_tt_reg_write( unsigned char reg, unsigned char value
  7381. -                                     );
  7382. -static unsigned char atari_scsi_falcon_reg_read( unsigned char reg );
  7383. -static void atari_scsi_falcon_reg_write( unsigned char reg, unsigned char
  7384. -                                         value );
  7385. -
  7386. -/************************* End of Prototypes **************************/
  7387. -
  7388. -
  7389. -static struct Scsi_Host *atari_scsi_host = NULL;
  7390. -static unsigned char (*atari_scsi_reg_read)( unsigned char reg );
  7391. -static void (*atari_scsi_reg_write)( unsigned char reg, unsigned char value );
  7392. -
  7393. -#ifdef REAL_DMA
  7394. -static unsigned long    atari_dma_residual, atari_dma_startaddr;
  7395. -static short            atari_dma_active;
  7396. -#endif
  7397. -
  7398. -
  7399. -#if defined(REAL_DMA)
  7400. -
  7401. -static int scsi_dma_is_ignored_buserr( unsigned char dma_stat )
  7402. -
  7403. -{    int                i;
  7404. -    unsigned long    addr = SCSI_DMA_READ_P( dma_addr_hi ), end_addr;
  7405. -
  7406. -    if (dma_stat & 0x01) {
  7407. -
  7408. -        /* A bus error happens when DMA-ing from the last page of a
  7409. -         * physical memory chunk (DMA prefetch!), but that doesn't hurt.
  7410. -         * Check for this case:
  7411. -         */
  7412. -        
  7413. -        for( i = 0; i < boot_info.num_memory; ++i ) {
  7414. -            end_addr = boot_info.memory[i].addr +
  7415. -                boot_info.memory[i].size;
  7416. -            if (end_addr <= addr && addr <= end_addr + 4)
  7417. -                return( 1 );
  7418. -        }
  7419. -    }
  7420. -    return( 0 );
  7421. -}
  7422. -
  7423. -
  7424. -static void scsi_dma_buserr (struct intframe *fp, void *data)
  7425. -
  7426. -{    unsigned char    dma_stat = tt_scsi_dma.dma_ctrl;
  7427. -
  7428. -    printk( "Bad SCSI DMA inmterrupt! dma_addr=0x%08lx dma_stat=%02x dma_cnt=%08lx\n",
  7429. -            SCSI_DMA_READ_P( dma_addr_hi ), dma_stat, SCSI_DMA_READ_P( dma_cnt_hi ) );
  7430. -    if (dma_stat & 0x80) {
  7431. -        if (!scsi_dma_is_ignored_buserr( dma_stat ))
  7432. -            panic( "SCSI DMA bus error -- bad DMA programming!" );
  7433. -    }
  7434. -    else {
  7435. -        /* Under normal circumstances we never should get to this point,
  7436. -         * since both interrupts are triggered simultaneosly and the 5380
  7437. -         * int has more priotity. When this irq is handled, that DMA
  7438. -         * interrupt is cleared. So a warning message is printed here.
  7439. -         */
  7440. -        printk( "SCSI DMA intr ?? -- this shouldn't happen!\n" );
  7441. -    }
  7442. -}
  7443. -
  7444. -#endif
  7445. -
  7446. -#undef    LOST_INTR
  7447. -
  7448. -#ifdef LOST_INTR
  7449. -extern volatile unsigned long intr_count;
  7450. -unsigned long curr_intr_count;
  7451. -
  7452. -#define    CHECK_ICNT(pos) do {                    \
  7453. - if (intr_count != curr_intr_count) {            \
  7454. -     printk( "INTR_COUNT changed before " pos    \
  7455. -             ": curr_cnt=%lu intr_cnt=%lu\n",    \
  7456. -             curr_intr_count, intr_count );        \
  7457. - }                                                \
  7458. -} while( 0 )
  7459. -
  7460. -#else
  7461. -
  7462. -#define    CHECK_ICNT(pos)
  7463. -
  7464. -#endif
  7465. -
  7466. -
  7467. -static void scsi_tt_intr (struct intframe *fp, void *data)
  7468. -
  7469. -{    int                dma_stat;
  7470. -    unsigned long    flags;
  7471. -#ifdef LOST_INTR
  7472. -    unsigned long    prev_intr_count;
  7473. -
  7474. -    prev_intr_count = curr_intr_count;
  7475. -    curr_intr_count = intr_count;
  7476. -#endif
  7477. -    
  7478. -#ifdef REAL_DMA
  7479. -
  7480. -    dma_stat = tt_scsi_dma.dma_ctrl;
  7481. -
  7482. -#if (NDEBUG & NDEBUG_INTR)
  7483. -    printk( "scsi%d: NCR5380 interupt, DMA status = %02x\n",
  7484. -            atari_scsi_host->host_no, dma_stat & 0xff );
  7485. -#endif
  7486. -
  7487. -    /* Look if it was the DMA that has interrupted: First possibility
  7488. -     * is that a bus error occured...
  7489. -     */
  7490. -    if (dma_stat & 0x80) {
  7491. -        if (!scsi_dma_is_ignored_buserr( dma_stat )) {
  7492. -            printk( "SCSI DMA caused bus error near 0x%08lx\n",
  7493. -                    SCSI_DMA_READ_P( dma_addr_hi ));
  7494. -            panic( "SCSI DMA bus error -- bad DMA programming!" );
  7495. -        }
  7496. -    }
  7497. -
  7498. -    /* If the DMA is active but not finished, we have the the case
  7499. -     * that some other 5380 interrupt occured within the DMA transfer.
  7500. -     * This means we have residual bytes, if the desired end address
  7501. -     * is not yet reached. Maybe we have to fetch some bytes from the
  7502. -     * rest data register, too. The residual must be calculated from
  7503. -     * the address pointer, not the counter register, because only the
  7504. -     * addr reg counts bytes not yet written and pending in the rest
  7505. -     * data reg!
  7506. -     */
  7507. -    if ((dma_stat & 0x02) && !(dma_stat & 0x40)) {
  7508. -        atari_dma_residual =
  7509. -            ((struct NCR5380_hostdata *)(atari_scsi_host->hostdata))->dma_len -
  7510. -                (SCSI_DMA_READ_P( dma_addr_hi ) - atari_dma_startaddr);
  7511. -#if (NDEBUG & NDEBUG_DMA)
  7512. -        printk( "SCSI DMA: There are %ld residual bytes.\n",
  7513. -                atari_dma_residual );
  7514. -#endif
  7515. -        atari_scsi_fetch_restbytes();
  7516. -        tt_scsi_dma.dma_ctrl = 0;
  7517. -    }
  7518. -
  7519. -    /* If the DMA is finished, fetch the rest bytes and turn it off */
  7520. -    if (dma_stat & 0x40) {
  7521. -        atari_dma_residual = 0;
  7522. -        atari_scsi_fetch_restbytes();
  7523. -        tt_scsi_dma.dma_ctrl = 0;
  7524. -    }
  7525. -
  7526. -#endif /* REAL_DMA */
  7527. -    
  7528. -    /* If we got this interrupt, we don't need the other one any more */
  7529. -    tt_mfp.int_pn_b = (unsigned char)~0x80;
  7530. -
  7531. -    CHECK_ICNT("calling NCR5380_intr");
  7532. -
  7533. -    save_flags(flags);
  7534. -    NCR5380_intr( 0 );
  7535. -    restore_flags(flags);
  7536. -
  7537. -#ifdef LOST_INTR
  7538. -    CHECK_ICNT("returning, after NCR5380_intr");
  7539. -    curr_intr_count = prev_intr_count;
  7540. -#endif
  7541. -}
  7542. -
  7543. -
  7544. -static void scsi_falcon_intr (struct intframe *fp, void *data)
  7545. -
  7546. -{    int                dma_stat;
  7547. -    unsigned long    flags;
  7548. -#ifdef LOST_INTR
  7549. -    unsigned long    prev_intr_count;
  7550. -
  7551. -    prev_intr_count = curr_intr_count;
  7552. -    curr_intr_count = intr_count;
  7553. -#endif
  7554. -    
  7555. -#ifdef REAL_DMA
  7556. -
  7557. -    /* Turn off DMA and select sector counter register before
  7558. -     * accessing the status register (Atari recommendation!)
  7559. -     */
  7560. -    st_dma.dma_mode_status = 0x90;
  7561. -    dma_stat = st_dma.dma_mode_status;
  7562. -
  7563. -    /* Bit 0 indicates some error in the DMA process... don't know
  7564. -     * what happened exactly (no further docu).
  7565. -     */
  7566. -    if (!(dma_stat & 0x01)) {
  7567. -        /* DMA error */
  7568. -        printk( "SCSI DMA error near 0x%08lx!\n", SCSI_DMA_GETADR() );
  7569. -    }
  7570. -
  7571. -    /* If the DMA was active, but now bit 1 is not clear, it is some
  7572. -     * other 5380 interrupt that finishes the DMA transfer. We have to
  7573. -     * calculate the number of residual bytes and give a warning if
  7574. -     * bytes are stuck in the ST-DMA fifo (there's no way to reach them!)
  7575. -     */
  7576. -    if (atari_dma_active && (dma_stat & 0x02)) {
  7577. -        unsigned long    transferred;
  7578. -
  7579. -        transferred = SCSI_DMA_GETADR() - atari_dma_startaddr;
  7580. -        /* The ST-DMA address is incremented in 2-byte steps, but the
  7581. -         * data are written only in 16-byte chunks. If the number of
  7582. -         * transferred bytes is not divisible by 16, the remainder is
  7583. -         * lost somewhere in outer space.
  7584. -         */
  7585. -        if (transferred & 15)
  7586. -            printk( "SCSI DMA error: %ld bytes lost in ST-DMA fifo :-((\n",
  7587. -                    transferred & 15 );
  7588. -
  7589. -        atari_dma_residual =
  7590. -            ((struct NCR5380_hostdata *)(atari_scsi_host->hostdata))->dma_len -
  7591. -                transferred;
  7592. -#if (NDEBUG & NDEBUG_DMA)
  7593. -        printk( "SCSI DMA: There are %ld residual bytes.\n",
  7594. -                atari_dma_residual );
  7595. -#endif
  7596. -    }
  7597. -    else
  7598. -        atari_dma_residual = 0;
  7599. -    atari_dma_active = 0;
  7600. -    
  7601. -#endif /* REAL_DMA */
  7602. -
  7603. -    CHECK_ICNT("calling NCR5380_intr");
  7604. -
  7605. -    save_flags(flags);
  7606. -    NCR5380_intr( 0 );
  7607. -    restore_flags(flags);
  7608. -
  7609. -#ifdef LOST_INTR
  7610. -    CHECK_ICNT("returning, after NCR5380_intr");
  7611. -    curr_intr_count = prev_intr_count;
  7612. -#endif
  7613. -}
  7614. -
  7615. -
  7616. -static void atari_scsi_fetch_restbytes( void )
  7617. -
  7618. -{    int        nr;
  7619. -    char    *src, *dst;
  7620. -
  7621. -    /* fetch rest bytes in the DMA register */
  7622. -    dst = (char *)SCSI_DMA_READ_P( dma_addr_hi );
  7623. -    if ((nr = ((long)dst & 3))) {
  7624. -        /* there are 'nr' bytes left for the last long address before the
  7625. -           DMA pointer */
  7626. -        dst = (char *)( (unsigned long)dst & ~3 );
  7627. -#if (NDEBUG & NDEBUG_DMA)
  7628. -        printk( "SCSI DMA: there are %d rest bytes for phys addr 0x%08lx",
  7629. -                nr, (long)dst );
  7630. -#endif
  7631. -        dst = (char *)PTOV(dst);  /* The content of the DMA pointer
  7632. -                                   * is a physical address! */
  7633. -#if (NDEBUG & NDEBUG_DMA)
  7634. -        printk( " = virt addr 0x%08lx\n", (long)dst );
  7635. -#endif
  7636. -        for( src = (char *)&tt_scsi_dma.dma_restdata; nr > 0; --nr )
  7637. -            *dst++ = *src++;
  7638. -    }
  7639. -}
  7640. -
  7641. -
  7642. -static int                    falcon_got_lock = 0;
  7643. -static struct wait_queue    *falcon_fairness_wait = NULL;
  7644. -static int                    falcon_trying_lock = 0;
  7645. -static struct wait_queue    *falcon_try_wait = NULL;
  7646. -
  7647. -/* This function releases the lock on the DMA chip if there is no
  7648. - * connected command and the disconnected queue is empty. On
  7649. - * releasing, instances of falcon_get_lock are awoken, that put
  7650. - * themselves to sleep for fairness. They can now try to get the lock
  7651. - * again (but others waiting longer more probably will win).
  7652. - */
  7653. -
  7654. -static void
  7655. -falcon_release_lock_if_possible( struct NCR5380_hostdata * hostdata )
  7656. -
  7657. -{
  7658. -    if (IS_A_TT()) return;
  7659. -    
  7660. -    if (falcon_got_lock &&
  7661. -        !hostdata->disconnected_queue &&
  7662. -        !hostdata->issue_queue &&
  7663. -        !hostdata->connected) {
  7664. -
  7665. -        unsigned long    oldflags;
  7666. -
  7667. -        save_flags(oldflags);
  7668. -        cli();
  7669. -        
  7670. -        falcon_got_lock = 0;
  7671. -        stdma_release();
  7672. -        wake_up( &falcon_fairness_wait );
  7673. -
  7674. -        restore_flags(oldflags);
  7675. -    }
  7676. -}
  7677. -
  7678. -/* This function manages the locking of the ST-DMA.
  7679. - * If the DMA isn't locked already for SCSI, it trys to lock it by
  7680. - * calling stdma_lock(). But if the DMA is locked by the SCSI code and
  7681. - * there are other drivers waiting for the chip, we do not issue the
  7682. - * command immediatly but wait on 'falcon_fairness_queue'. We will be
  7683. - * waked up when the DMA is unlocked by some SCSI interrupt. After that
  7684. - * we try to get the lock again.
  7685. - * But we must be prepared that more then one instance of
  7686. - * falcon_get_lock() is waiting on the fairness queue. They should not
  7687. - * try all at once to call stdma_lock(), one is enough! For that, the
  7688. - * first one sets 'falcon_trying_lock', others that see that variable
  7689. - * set wait on the queue 'falcon_try_wait'.
  7690. - * Complicated, complicated.... Sigh...
  7691. - */
  7692. -
  7693. -static void falcon_get_lock( void )
  7694. -
  7695. -{
  7696. -    unsigned long    oldflags;
  7697. -    
  7698. -    if (IS_A_TT()) return;
  7699. -
  7700. -    save_flags(oldflags);
  7701. -    cli();
  7702. -    
  7703. -    while( falcon_got_lock && stdma_others_waiting() )
  7704. -        sleep_on( &falcon_fairness_wait );
  7705. -
  7706. -    if (!falcon_got_lock) {
  7707. -        if (!falcon_trying_lock) {
  7708. -            falcon_trying_lock = 1;
  7709. -            stdma_lock( scsi_falcon_intr, 0 );
  7710. -            falcon_got_lock = 1;
  7711. -            falcon_trying_lock = 0;
  7712. -            wake_up( &falcon_try_wait );
  7713. -        }
  7714. -        else {
  7715. -            sleep_on( &falcon_try_wait );
  7716. -        }
  7717. -    }    
  7718. -
  7719. -    restore_flags(oldflags);
  7720. -}
  7721. -
  7722. -
  7723. -/* This is the wrapper function for NCR5380_queue_command(). It just
  7724. - * trys to get the lock on the ST-DMA (see above) and then calls the
  7725. - * original function.
  7726. - */
  7727. -
  7728. -int atari_queue_command (Scsi_Cmnd *cmd, void (*done)(Scsi_Cmnd *))
  7729. -
  7730. -{
  7731. -    falcon_get_lock();
  7732. -    return( NCR5380_queue_command( cmd, done ) );
  7733. -}
  7734. -
  7735. -
  7736. -                   
  7737. -int atari_scsi_detect (int hostno)
  7738. -
  7739. -{    static int called = 0;
  7740. -    struct Scsi_Host *instance;
  7741. -
  7742. -    if (boot_info.machtype != MACH_ATARI || called)
  7743. -        return( 0 );
  7744. -    
  7745. -    atari_scsi_reg_read  = IS_A_TT() ? atari_scsi_tt_reg_read :
  7746. -                                       atari_scsi_falcon_reg_read;
  7747. -    atari_scsi_reg_write = IS_A_TT() ? atari_scsi_tt_reg_write :
  7748. -                                       atari_scsi_falcon_reg_write;
  7749. -
  7750. -    instance = scsi_register (hostno, sizeof (struct NCR5380_hostdata));
  7751. -    atari_scsi_host = instance;
  7752. -
  7753. -    NCR5380_init (instance);
  7754. -    instance->irq = 0;    /* not needed, but tested in NCR5380.c */
  7755. -
  7756. -    if (IS_A_TT()) {
  7757. -        
  7758. -        add_isr( IRQ_TT_MFP_SCSI, scsi_tt_intr, 0, NULL);
  7759. -        tt_mfp.active_edge |= 0x80;        /* SCSI int on L->H */
  7760. -        tt_mfp.int_en_a |= 0x80;        /* enabled */
  7761. -        tt_mfp.int_mk_a |= 0x80;        /* not masked */
  7762. -#ifdef REAL_DMA
  7763. -        /* On the TT, we got a second interrupt for DMA ready and DMA buserror.
  7764. -         * Since on DMA ready we get a "normal" interrupt, too, the service
  7765. -         * routine for the second int just checks for buserrs.
  7766. -         */
  7767. -        add_isr( IRQ_TT_MFP_SCSIDMA, scsi_dma_buserr, 0, NULL);
  7768. -        tt_mfp.active_edge &= ~0x20;    /* DMA int on H->L */
  7769. -        tt_mfp.int_en_b |= 0x80;        /* enabled */
  7770. -        tt_mfp.int_mk_b |= 0x80;        /* not masked */
  7771. -
  7772. -        tt_scsi_dma.dma_ctrl = 0;
  7773. -        atari_dma_residual = 0;
  7774. -#endif /* REAL_DMA */
  7775. -
  7776. -    }
  7777. -    else { /* ! IS_A_TT */
  7778. -        
  7779. -        /* Nothing to do for the interrupt: the ST-DMA is initialized
  7780. -         * already by atari_init_INTS()
  7781. -         */
  7782. -
  7783. -#ifdef REAL_DMA
  7784. -        atari_dma_residual = 0;
  7785. -        atari_dma_active = 0;
  7786. -#endif
  7787. -
  7788. -        /* Falcon's ST-DMA can work only in lower 16 MB, so
  7789. -         * unchecked_isa_dma has to be set. But... the high level
  7790. -         * codes allocates lots (!) of memory for buffers if this is
  7791. -         * done. So the values for sg_tablesize and cmd_per_lun get
  7792. -         * lowered a bit (you can leave this out if you have 16MB of
  7793. -         * ST-Ram).
  7794. -         */
  7795. -        atari_scsi_host->unchecked_isa_dma =
  7796. -        atari_scsi_host->hostt->unchecked_isa_dma = 1;
  7797. -#if I_HAVE_OVERRUNS == 3
  7798. -        atari_scsi_host->sg_tablesize =
  7799. -        atari_scsi_host->hostt->sg_tablesize = SG_NONE;
  7800. -#else
  7801. -        atari_scsi_host->sg_tablesize =
  7802. -        atari_scsi_host->hostt->sg_tablesize = 8;
  7803. -#endif
  7804. -        atari_scsi_host->hostt->cmd_per_lun = 8;
  7805. -    }
  7806. -    
  7807. -    printk( "scsi%d: options CAN_QUEUE=%d CMD_PER_LUN=%d SCATTERGATHER=%d",
  7808. -            instance->host_no, instance->hostt->can_queue,
  7809. -            instance->hostt->cmd_per_lun,
  7810. -            instance->hostt->sg_tablesize );
  7811. -    NCR5380_print_options (instance);
  7812. -    printk ("\n");
  7813. -
  7814. -    called = 1;
  7815. -
  7816. -    return( 1 );
  7817. -}
  7818. -
  7819. -int atari_scsi_reset( Scsi_Cmnd *cmd )
  7820. -
  7821. -{    int        rv;
  7822. -    
  7823. -    /* For doing the reset, SCSI interrupts must be disabled first,
  7824. -     * since the 5380 raises its IRQ line while _RST is active and we
  7825. -     * can't disable interrupts completely, since we need the timer.
  7826. -     */
  7827. -    
  7828. -    if (IS_A_TT())
  7829. -        tt_mfp.int_en_a &= ~0x80;
  7830. -    else
  7831. -        mfp.int_en_b &= ~0x80;
  7832. -    
  7833. -    rv = NCR5380_reset( cmd );
  7834. -
  7835. -    /* Re-enable ints and abort a maybe active DMA transfer */
  7836. -    if (IS_A_TT()) {
  7837. -#ifdef REAL_DMA
  7838. -        tt_scsi_dma.dma_ctrl = 0;
  7839. -#endif /* REAL_DMA */
  7840. -        tt_mfp.int_en_a |= 0x80;
  7841. -    }
  7842. -    else {
  7843. -#ifdef REAL_DMA
  7844. -        st_dma.dma_mode_status = 0x90;
  7845. -        atari_dma_active = 0;
  7846. -#endif /* REAL_DMA */
  7847. -        mfp.int_en_b |= 0x80;
  7848. -    }
  7849. -
  7850. -    return( rv );
  7851. -}
  7852. -
  7853. -    
  7854. -const char * atari_scsi_info( void )
  7855. -
  7856. -{    /* atari_scsi_detect() is verbose enough... */
  7857. -    static const char string[] = "";
  7858. -    return string;
  7859. -}
  7860. -
  7861. -
  7862. -#if defined(REAL_DMA) || defined(REAL_DMA_POLL) || defined(PSEUDO_DMA)
  7863. -
  7864. -unsigned long atari_scsi_dma_setup( struct Scsi_Host *instance, void *data,
  7865. -                                    unsigned long count, int dir )
  7866. -{
  7867. -    unsigned long addr = VTOP( data ),
  7868. -                  cando = atari_dma_xfer_len( count );
  7869. -
  7870. -#if (NDEBUG & NDEBUG_DMA)
  7871. -    printk ("scsi%d: setting up dma, data = %p, phys = %lx, count = %ld, cando = %ld, dir = %d\n",
  7872. -            instance->host_no, data, addr, count, cando, dir);
  7873. -#endif
  7874. -
  7875. -    atari_dma_startaddr = addr;    /* Needed for calculating residual later. */
  7876. -  
  7877. -    if (dir)
  7878. -        /* write: push any dirty cache out before sending it to the
  7879. -         * peripheral. (Must be done before DMA setup, since at least the
  7880. -         * ST-DMA begins to fill internal buffers right after setup.
  7881. -         */
  7882. -        cache_push( addr, cando );
  7883. -    else
  7884. -        /* read: invalidate any cache, may be altered after DMA without CPU
  7885. -         * knowledge
  7886. -         */
  7887. -        cache_clear( addr, cando );
  7888. -
  7889. -    if (cando == 0)
  7890. -        printk( "SCSI warning: DMA programed for 0 bytes !\n" );
  7891. -
  7892. -    if (IS_A_TT()) {
  7893. -    
  7894. -        tt_scsi_dma.dma_ctrl = dir;
  7895. -        SCSI_DMA_WRITE_P( dma_addr_hi, addr );
  7896. -        SCSI_DMA_WRITE_P( dma_cnt_hi, cando );
  7897. -        tt_scsi_dma.dma_ctrl = dir | 2;
  7898. -    }
  7899. -    else { /* ! IS_A_TT */
  7900. -  
  7901. -        /* set address */
  7902. -        SCSI_DMA_SETADR( addr );
  7903. -
  7904. -        /* toggle direction bit to clear FIFO and set DMA direction */
  7905. -        dir <<= 8;
  7906. -        st_dma.dma_mode_status = 0x90 | dir;
  7907. -        st_dma.dma_mode_status = 0x90 | (dir ^ 0x100);
  7908. -        st_dma.dma_mode_status = 0x90 | dir;
  7909. -        st_dma.fdc_acces_seccount = cando >> 9;
  7910. -
  7911. -        st_dma.dma_mode_status = 0x10 | dir;
  7912. -        /* need not restore value of dir, only boolean value is tested */
  7913. -        atari_dma_active = 1;
  7914. -    }
  7915. -    
  7916. -    return( cando );
  7917. -}
  7918. -
  7919. -
  7920. -static long atari_scsi_dma_residual( struct Scsi_Host *instance )
  7921. -
  7922. -{
  7923. -    return( atari_dma_residual );
  7924. -}
  7925. -
  7926. -/* This function calculates the number of bytes that can be transferred
  7927. - * via DMA. On the TT, this is arbitrary, but on the Falcon we have to use
  7928. - * the ST-DMA chip. There are only multiples of 512 bytes possible and
  7929. - * max. 256*512 bytes :-( This means also, that defining READ_OVERRUNS is
  7930. - * not possible, since that would require to program the DMA for n*512 - 2
  7931. - * bytes.
  7932. - */
  7933. -
  7934. -static unsigned long atari_dma_xfer_len( unsigned long wanted_len )
  7935. -
  7936. -{
  7937. -    unsigned long    possible_len;
  7938. -
  7939. -    if (IS_A_TT())
  7940. -        /* TT SCSI DMA can transfer arbitrary #bytes */
  7941. -        return( wanted_len );
  7942. -    
  7943. -    /* ST DMA chip is stupid -- only multiples of 512 bytes! (and max.
  7944. -     * 255*512 bytes, but this should be enough)
  7945. -     */
  7946. -    possible_len =wanted_len & ~0x1ff;
  7947. -    if (possible_len > 255*512)
  7948. -        possible_len = 255*512;
  7949. -
  7950. -#if (NDEBUG & NDEBUG_DMA)
  7951. -    if (possible_len != wanted_len)
  7952. -        printk( "Sorry, must cut DMA transfer size to %ld bytes instead of %ld\n",
  7953. -                possible_len, wanted_len );
  7954. -#endif
  7955. -
  7956. -    return( possible_len );
  7957. -}
  7958. -
  7959. -
  7960. -#endif    /* REAL_DMA || REAL_DMA_POLL || PSEUDO_DMA */
  7961. -
  7962. -
  7963. -/* NCR5380 register access functions
  7964. - *
  7965. - * There are seperate functions for TT and Falcon, because the access
  7966. - * methods are quite different. The calling macros NCR5380_read and
  7967. - * NCR5380_write call these functions via function pointers.
  7968. - */
  7969. -
  7970. -static unsigned char atari_scsi_tt_reg_read( unsigned char reg )
  7971. -
  7972. -{
  7973. -    return( tt_scsi_regp[reg * 2] );
  7974. -}
  7975. -
  7976. -static void atari_scsi_tt_reg_write( unsigned char reg, unsigned char value )
  7977. -
  7978. -{
  7979. -    tt_scsi_regp[reg * 2] = value;
  7980. -}
  7981. -
  7982. -static unsigned char atari_scsi_falcon_reg_read( unsigned char reg )
  7983. -
  7984. -{
  7985. -    dma_wd.dma_mode_status= (u_short)(0x88 + reg);
  7986. -    return( (u_char)dma_wd.fdc_acces_seccount );
  7987. -}
  7988. -
  7989. -static void atari_scsi_falcon_reg_write( unsigned char reg, unsigned char value )
  7990. -
  7991. -{
  7992. -    dma_wd.dma_mode_status = (u_short)(0x88 + reg);
  7993. -    dma_wd.fdc_acces_seccount = (u_short)value;
  7994. -}
  7995. -
  7996. -
  7997. -#include "atari_NCR5380.c"
  7998. -
  7999. -#endif /* CONFIG_ATARI_*_SCSI */
  8000. diff -ubr -x RCS -x *.[ao] -x .depend -x .version -x .config -x System.map -x vmlinux -x bootstrap -x *~ -x config.old -x *.orig -x *.rej -x *# -x version.h -x autoconf.h --new-file linux-0.9pl3/drivers/scsi/atari_scsi.c linux-0.9pl4/drivers/scsi/atari_scsi.c
  8001. --- linux-0.9pl3/drivers/scsi/atari_scsi.c    Wed Dec 31 19:00:00 1969
  8002. +++ linux-0.9pl4/drivers/scsi/atari_scsi.c    Mon Nov  7 22:28:17 1994
  8003. @@ -0,0 +1,766 @@
  8004. +/*
  8005. + * atari_scsi.c -- Device dependant functions for the Atari generic SCSI port
  8006. + *
  8007. + * Copyright 1994 Roman Hodek
  8008. + *   EMail: rnhodek@cip.informatik.uni-erlangen.de (Internet)
  8009. + *      or: Roman_Hodek@n.maus.de (MausNet, NO mail > 16 KB!)
  8010. + *
  8011. + *   Loosely based on the work of Robert De Vries' team and added:
  8012. + *    - working real DMA
  8013. + *    - Falcon support (untested yet!)   ++bjoern fixed and now it works
  8014. + *    - lots of extensions and bug fixes.
  8015. + *
  8016. + * This file is subject to the terms and conditions of the GNU General Public
  8017. + * License.  See the file README.legal in the main directory of this archive
  8018. + * for more details.
  8019. + *
  8020. + */
  8021. +
  8022. +
  8023. +/**************************************************************************/
  8024. +/*                                                                        */
  8025. +/* Notes for Falcon SCSI:                                                 */
  8026. +/* ----------------------                                                 */
  8027. +/*                                                                        */
  8028. +/* Since the Falcon SCSI uses the ST-DMA chip, that is shared among       */
  8029. +/* several device drivers, locking and unlocking the access to this       */
  8030. +/* chip is required. But locking is not possible from an interrupt,       */
  8031. +/* since it puts the process to sleep if the lock is not available.       */
  8032. +/* This prevents "late" locking of the DMA chip, i.e. locking it just     */
  8033. +/* before using it, since in case of disconnection-reconnection           */
  8034. +/* commands, the DMA is started from the reselection interrupt.           */
  8035. +/*                                                                        */
  8036. +/* Two possible schemes for ST-DMA-locking would be:                      */
  8037. +/*  1) The lock is taken for each command separately and disconnecting    */
  8038. +/*     is forbidden (i.e. can_queue = 1).                                 */
  8039. +/*  2) The DMA chip is locked when the first command comes in and         */
  8040. +/*     released when the last command is finished and all queues are      */
  8041. +/*     empty.                                                             */
  8042. +/* The first alternative would result in bad performance, since the       */
  8043. +/* interleaving of commands would not be used. The second is unfair to    */
  8044. +/* other drivers using the ST-DMA, because the queues will seldom be      */
  8045. +/* totally empty if there is a lot of disk traffic.                       */
  8046. +/*                                                                        */
  8047. +/* For this reasons I decided to employ a more elaborate scheme:          */
  8048. +/*  - First, we give up the lock everytime we can (for fairness), this    */
  8049. +/*    means every time a command finishes and there are no other commands */
  8050. +/*    on the disconnected queue.                                          */
  8051. +/*  - If there are others waiting to lock the DMA chip, we stop           */
  8052. +/*    issueing commands, i.e. moving them onto the issue queue.           */
  8053. +/*    Because of that, the disconnected queue will run empty in a         */
  8054. +/*    while. Instead we go to sleep on a 'fairness_queue'.                */
  8055. +/*  - If the lock is released, all processes waiting on the fairness      */
  8056. +/*    queue will be woken. The first of them trys to re-lock the DMA,     */
  8057. +/*    the others wait for the first to finish this task. After that,      */
  8058. +/*    they can all run on and do their commands...                        */
  8059. +/* This sounds complicated (and it is it :-(), but it seems to be a       */
  8060. +/* good compromise between fairness and performance: As long as noone     */
  8061. +/* else wants to work with the ST-DMA chip, SCSI can go along as          */
  8062. +/* usual. If now someone else comes, this behaviour is changed to a       */
  8063. +/* "fairness mode": just already initiated commands are finished and      */
  8064. +/* then the lock is released. The other one waiting will probably win     */
  8065. +/* the race for locking the DMA, since it was waiting for longer. And     */
  8066. +/* after it has finished, SCSI can go ahead again. Finally: I hope I      */
  8067. +/* have not produced any deadlock possibilites!                           */
  8068. +/*                                                                        */
  8069. +/**************************************************************************/
  8070. +
  8071. +
  8072. +
  8073. +#include <linux/config.h>
  8074. +
  8075. +#ifdef CONFIG_ATARI_SCSI
  8076. +
  8077. +/* #define NDEBUG (NDEBUG_DMA) */
  8078. +
  8079. +#define AUTOSENSE
  8080. +/* For the Atari version, use only polled IO or REAL_DMA */
  8081. +#define    REAL_DMA
  8082. +
  8083. +#if I_HAVE_OVERRUNS == 1 || I_HAVE_OVERRUNS == 2
  8084. +#define    READ_OVERRUNS
  8085. +#endif
  8086. +
  8087. +#include <linux/types.h>
  8088. +#include <linux/stddef.h>
  8089. +#include <linux/interrupt.h>
  8090. +#include <linux/bootinfo.h>
  8091. +#include <linux/delay.h>
  8092. +#include <linux/atarihw.h>
  8093. +#include <linux/atariints.h>
  8094. +#include "../block/blk.h"
  8095. +#include "scsi.h"
  8096. +#include "hosts.h"
  8097. +#include "atari_scsi.h"
  8098. +#include "NCR5380.h"
  8099. +#include "constants.h"
  8100. +#include <linux/atari_stdma.h>
  8101. +
  8102. +
  8103. +#define    IS_A_TT()    (boot_info.bi_atari.model == ATARI_TT)
  8104. +
  8105. +#define    SCSI_DMA_WRITE_P(elt,val)                                    \
  8106. +    __asm__ __volatile__ ( "movepl %0,%1@(0)" : : "d" (val),        \
  8107. +                               "a" (&tt_scsi_dma.elt) );
  8108. +
  8109. +#define    SCSI_DMA_READ_P(elt) ({                                            \
  8110. +    unsigned long __val;                                                \
  8111. +    __asm__ __volatile__ ( "movepl %1@(0),%0"                            \
  8112. +                           : "=d" (__val) : "a" (&tt_scsi_dma.elt));    \
  8113. +    __val; })
  8114. +
  8115. +#define    SCSI_DMA_SETADR(adr)                    \
  8116. +    do {                                        \
  8117. +        unsigned long __adr = (adr);            \
  8118. +        st_dma.dma_lo = (unsigned char)__adr;    \
  8119. +        __adr >>= 8;                            \
  8120. +        st_dma.dma_md = (unsigned char)__adr;    \
  8121. +        __adr >>= 8;                            \
  8122. +        st_dma.dma_hi = (unsigned char)__adr;    \
  8123. +    } while(0)
  8124. +
  8125. +#define    SCSI_DMA_GETADR() ({                    \
  8126. +    unsigned long    __adr;                        \
  8127. +    __adr = st_dma.dma_lo;                        \
  8128. +    __asm__ __volatile__ ("nop");                \
  8129. +    __adr |= (st_dma.dma_md & 0xff) << 8;        \
  8130. +    __adr |= (st_dma.dma_hi & 0xff) << 16;        \
  8131. +    __adr;                                        \
  8132. +})
  8133. +
  8134. +
  8135. +
  8136. +/***************************** Prototypes *****************************/
  8137. +
  8138. +static void scsi_dma_buserr( struct intframe *fp, void *data);
  8139. +static void scsi_tt_intr( struct intframe *fp, void *data);
  8140. +static void scsi_falcon_intr( struct intframe *fp, void *data);
  8141. +static void atari_scsi_fetch_restbytes( void );
  8142. +static void falcon_release_lock_if_possible( struct NCR5380_hostdata *
  8143. +                                             hostdata );
  8144. +static void falcon_get_lock( void );
  8145. +static long atari_scsi_dma_residual( struct Scsi_Host *instance );
  8146. +static unsigned long atari_dma_xfer_len( unsigned long wanted_len );
  8147. +static unsigned char atari_scsi_tt_reg_read( unsigned char reg );
  8148. +static void atari_scsi_tt_reg_write( unsigned char reg, unsigned char value
  8149. +                                     );
  8150. +static unsigned char atari_scsi_falcon_reg_read( unsigned char reg );
  8151. +static void atari_scsi_falcon_reg_write( unsigned char reg, unsigned char
  8152. +                                         value );
  8153. +
  8154. +/************************* End of Prototypes **************************/
  8155. +
  8156. +
  8157. +static struct Scsi_Host *atari_scsi_host = NULL;
  8158. +static unsigned char (*atari_scsi_reg_read)( unsigned char reg );
  8159. +static void (*atari_scsi_reg_write)( unsigned char reg, unsigned char value );
  8160. +
  8161. +#ifdef REAL_DMA
  8162. +static unsigned long    atari_dma_residual, atari_dma_startaddr;
  8163. +static short            atari_dma_active;
  8164. +#endif
  8165. +
  8166. +
  8167. +#if defined(REAL_DMA)
  8168. +
  8169. +static int scsi_dma_is_ignored_buserr( unsigned char dma_stat )
  8170. +
  8171. +{    int                i;
  8172. +    unsigned long    addr = SCSI_DMA_READ_P( dma_addr_hi ), end_addr;
  8173. +
  8174. +    if (dma_stat & 0x01) {
  8175. +
  8176. +        /* A bus error happens when DMA-ing from the last page of a
  8177. +         * physical memory chunk (DMA prefetch!), but that doesn't hurt.
  8178. +         * Check for this case:
  8179. +         */
  8180. +        
  8181. +        for( i = 0; i < boot_info.num_memory; ++i ) {
  8182. +            end_addr = boot_info.memory[i].addr +
  8183. +                boot_info.memory[i].size;
  8184. +            if (end_addr <= addr && addr <= end_addr + 4)
  8185. +                return( 1 );
  8186. +        }
  8187. +    }
  8188. +    return( 0 );
  8189. +}
  8190. +
  8191. +
  8192. +static void scsi_dma_buserr (struct intframe *fp, void *data)
  8193. +
  8194. +{    unsigned char    dma_stat = tt_scsi_dma.dma_ctrl;
  8195. +
  8196. +    printk( "Bad SCSI DMA inmterrupt! dma_addr=0x%08lx dma_stat=%02x dma_cnt=%08lx\n",
  8197. +            SCSI_DMA_READ_P( dma_addr_hi ), dma_stat, SCSI_DMA_READ_P( dma_cnt_hi ) );
  8198. +    if (dma_stat & 0x80) {
  8199. +        if (!scsi_dma_is_ignored_buserr( dma_stat ))
  8200. +            panic( "SCSI DMA bus error -- bad DMA programming!" );
  8201. +    }
  8202. +    else {
  8203. +        /* Under normal circumstances we never should get to this point,
  8204. +         * since both interrupts are triggered simultaneosly and the 5380
  8205. +         * int has more priotity. When this irq is handled, that DMA
  8206. +         * interrupt is cleared. So a warning message is printed here.
  8207. +         */
  8208. +        printk( "SCSI DMA intr ?? -- this shouldn't happen!\n" );
  8209. +    }
  8210. +}
  8211. +
  8212. +#endif
  8213. +
  8214. +#undef    LOST_INTR
  8215. +
  8216. +#ifdef LOST_INTR
  8217. +extern volatile unsigned long intr_count;
  8218. +unsigned long curr_intr_count;
  8219. +
  8220. +#define    CHECK_ICNT(pos) do {                    \
  8221. + if (intr_count != curr_intr_count) {            \
  8222. +     printk( "INTR_COUNT changed before " pos    \
  8223. +             ": curr_cnt=%lu intr_cnt=%lu\n",    \
  8224. +             curr_intr_count, intr_count );        \
  8225. + }                                                \
  8226. +} while( 0 )
  8227. +
  8228. +#else
  8229. +
  8230. +#define    CHECK_ICNT(pos)
  8231. +
  8232. +#endif
  8233. +
  8234. +
  8235. +static void scsi_tt_intr (struct intframe *fp, void *data)
  8236. +
  8237. +{    int                dma_stat;
  8238. +    unsigned long    flags;
  8239. +#ifdef LOST_INTR
  8240. +    unsigned long    prev_intr_count;
  8241. +
  8242. +    prev_intr_count = curr_intr_count;
  8243. +    curr_intr_count = intr_count;
  8244. +#endif
  8245. +    
  8246. +#ifdef REAL_DMA
  8247. +
  8248. +    dma_stat = tt_scsi_dma.dma_ctrl;
  8249. +
  8250. +#if (NDEBUG & NDEBUG_INTR)
  8251. +    printk( "scsi%d: NCR5380 interupt, DMA status = %02x\n",
  8252. +            atari_scsi_host->host_no, dma_stat & 0xff );
  8253. +#endif
  8254. +
  8255. +    /* Look if it was the DMA that has interrupted: First possibility
  8256. +     * is that a bus error occured...
  8257. +     */
  8258. +    if (dma_stat & 0x80) {
  8259. +        if (!scsi_dma_is_ignored_buserr( dma_stat )) {
  8260. +            printk( "SCSI DMA caused bus error near 0x%08lx\n",
  8261. +                    SCSI_DMA_READ_P( dma_addr_hi ));
  8262. +            panic( "SCSI DMA bus error -- bad DMA programming!" );
  8263. +        }
  8264. +    }
  8265. +
  8266. +    /* If the DMA is active but not finished, we have the the case
  8267. +     * that some other 5380 interrupt occured within the DMA transfer.
  8268. +     * This means we have residual bytes, if the desired end address
  8269. +     * is not yet reached. Maybe we have to fetch some bytes from the
  8270. +     * rest data register, too. The residual must be calculated from
  8271. +     * the address pointer, not the counter register, because only the
  8272. +     * addr reg counts bytes not yet written and pending in the rest
  8273. +     * data reg!
  8274. +     */
  8275. +    if ((dma_stat & 0x02) && !(dma_stat & 0x40)) {
  8276. +        atari_dma_residual =
  8277. +            ((struct NCR5380_hostdata *)(atari_scsi_host->hostdata))->dma_len -
  8278. +                (SCSI_DMA_READ_P( dma_addr_hi ) - atari_dma_startaddr);
  8279. +#if (NDEBUG & NDEBUG_DMA)
  8280. +        printk( "SCSI DMA: There are %ld residual bytes.\n",
  8281. +                atari_dma_residual );
  8282. +#endif
  8283. +        atari_scsi_fetch_restbytes();
  8284. +        tt_scsi_dma.dma_ctrl = 0;
  8285. +    }
  8286. +
  8287. +    /* If the DMA is finished, fetch the rest bytes and turn it off */
  8288. +    if (dma_stat & 0x40) {
  8289. +        atari_dma_residual = 0;
  8290. +        atari_scsi_fetch_restbytes();
  8291. +        tt_scsi_dma.dma_ctrl = 0;
  8292. +    }
  8293. +
  8294. +#endif /* REAL_DMA */
  8295. +    
  8296. +    /* If we got this interrupt, we don't need the other one any more */
  8297. +    tt_mfp.int_pn_b = (unsigned char)~0x80;
  8298. +
  8299. +    CHECK_ICNT("calling NCR5380_intr");
  8300. +
  8301. +    save_flags(flags);
  8302. +    NCR5380_intr( 0 );
  8303. +    restore_flags(flags);
  8304. +
  8305. +#ifdef LOST_INTR
  8306. +    CHECK_ICNT("returning, after NCR5380_intr");
  8307. +    curr_intr_count = prev_intr_count;
  8308. +#endif
  8309. +}
  8310. +
  8311. +
  8312. +static void scsi_falcon_intr (struct intframe *fp, void *data)
  8313. +
  8314. +{    int                dma_stat;
  8315. +    unsigned long    flags;
  8316. +#ifdef LOST_INTR
  8317. +    unsigned long    prev_intr_count;
  8318. +
  8319. +    prev_intr_count = curr_intr_count;
  8320. +    curr_intr_count = intr_count;
  8321. +#endif
  8322. +    
  8323. +#ifdef REAL_DMA
  8324. +
  8325. +    /* Turn off DMA and select sector counter register before
  8326. +     * accessing the status register (Atari recommendation!)
  8327. +     */
  8328. +    st_dma.dma_mode_status = 0x90;
  8329. +    dma_stat = st_dma.dma_mode_status;
  8330. +
  8331. +    /* Bit 0 indicates some error in the DMA process... don't know
  8332. +     * what happened exactly (no further docu).
  8333. +     */
  8334. +    if (!(dma_stat & 0x01)) {
  8335. +        /* DMA error */
  8336. +        printk( "SCSI DMA error near 0x%08lx!\n", SCSI_DMA_GETADR() );
  8337. +    }
  8338. +
  8339. +    /* If the DMA was active, but now bit 1 is not clear, it is some
  8340. +     * other 5380 interrupt that finishes the DMA transfer. We have to
  8341. +     * calculate the number of residual bytes and give a warning if
  8342. +     * bytes are stuck in the ST-DMA fifo (there's no way to reach them!)
  8343. +     */
  8344. +    if (atari_dma_active && (dma_stat & 0x02)) {
  8345. +        unsigned long    transferred;
  8346. +
  8347. +        transferred = SCSI_DMA_GETADR() - atari_dma_startaddr;
  8348. +        /* The ST-DMA address is incremented in 2-byte steps, but the
  8349. +         * data are written only in 16-byte chunks. If the number of
  8350. +         * transferred bytes is not divisible by 16, the remainder is
  8351. +         * lost somewhere in outer space.
  8352. +         */
  8353. +        if (transferred & 15)
  8354. +            printk( "SCSI DMA error: %ld bytes lost in ST-DMA fifo :-((\n",
  8355. +                    transferred & 15 );
  8356. +
  8357. +        atari_dma_residual =
  8358. +            ((struct NCR5380_hostdata *)(atari_scsi_host->hostdata))->dma_len -
  8359. +                transferred;
  8360. +#if (NDEBUG & NDEBUG_DMA)
  8361. +        printk( "SCSI DMA: There are %ld residual bytes.\n",
  8362. +                atari_dma_residual );
  8363. +#endif
  8364. +    }
  8365. +    else
  8366. +        atari_dma_residual = 0;
  8367. +    atari_dma_active = 0;
  8368. +    
  8369. +#endif /* REAL_DMA */
  8370. +
  8371. +    CHECK_ICNT("calling NCR5380_intr");
  8372. +
  8373. +    save_flags(flags);
  8374. +    NCR5380_intr( 0 );
  8375. +    restore_flags(flags);
  8376. +
  8377. +#ifdef LOST_INTR
  8378. +    CHECK_ICNT("returning, after NCR5380_intr");
  8379. +    curr_intr_count = prev_intr_count;
  8380. +#endif
  8381. +}
  8382. +
  8383. +
  8384. +static void atari_scsi_fetch_restbytes( void )
  8385. +
  8386. +{    int        nr;
  8387. +    char    *src, *dst;
  8388. +
  8389. +    /* fetch rest bytes in the DMA register */
  8390. +    dst = (char *)SCSI_DMA_READ_P( dma_addr_hi );
  8391. +    if ((nr = ((long)dst & 3))) {
  8392. +        /* there are 'nr' bytes left for the last long address before the
  8393. +           DMA pointer */
  8394. +        dst = (char *)( (unsigned long)dst & ~3 );
  8395. +#if (NDEBUG & NDEBUG_DMA)
  8396. +        printk( "SCSI DMA: there are %d rest bytes for phys addr 0x%08lx",
  8397. +                nr, (long)dst );
  8398. +#endif
  8399. +        dst = (char *)PTOV(dst);  /* The content of the DMA pointer
  8400. +                                   * is a physical address! */
  8401. +#if (NDEBUG & NDEBUG_DMA)
  8402. +        printk( " = virt addr 0x%08lx\n", (long)dst );
  8403. +#endif
  8404. +        for( src = (char *)&tt_scsi_dma.dma_restdata; nr > 0; --nr )
  8405. +            *dst++ = *src++;
  8406. +    }
  8407. +}
  8408. +
  8409. +
  8410. +static int                    falcon_got_lock = 0;
  8411. +static struct wait_queue    *falcon_fairness_wait = NULL;
  8412. +static int                    falcon_trying_lock = 0;
  8413. +static struct wait_queue    *falcon_try_wait = NULL;
  8414. +
  8415. +/* This function releases the lock on the DMA chip if there is no
  8416. + * connected command and the disconnected queue is empty. On
  8417. + * releasing, instances of falcon_get_lock are awoken, that put
  8418. + * themselves to sleep for fairness. They can now try to get the lock
  8419. + * again (but others waiting longer more probably will win).
  8420. + */
  8421. +
  8422. +static void
  8423. +falcon_release_lock_if_possible( struct NCR5380_hostdata * hostdata )
  8424. +
  8425. +{
  8426. +    if (IS_A_TT()) return;
  8427. +    
  8428. +    if (falcon_got_lock &&
  8429. +        !hostdata->disconnected_queue &&
  8430. +        !hostdata->issue_queue &&
  8431. +        !hostdata->connected) {
  8432. +
  8433. +        unsigned long    oldflags;
  8434. +
  8435. +        save_flags(oldflags);
  8436. +        cli();
  8437. +        
  8438. +        falcon_got_lock = 0;
  8439. +        stdma_release();
  8440. +        wake_up( &falcon_fairness_wait );
  8441. +
  8442. +        restore_flags(oldflags);
  8443. +    }
  8444. +}
  8445. +
  8446. +/* This function manages the locking of the ST-DMA.
  8447. + * If the DMA isn't locked already for SCSI, it trys to lock it by
  8448. + * calling stdma_lock(). But if the DMA is locked by the SCSI code and
  8449. + * there are other drivers waiting for the chip, we do not issue the
  8450. + * command immediatly but wait on 'falcon_fairness_queue'. We will be
  8451. + * waked up when the DMA is unlocked by some SCSI interrupt. After that
  8452. + * we try to get the lock again.
  8453. + * But we must be prepared that more then one instance of
  8454. + * falcon_get_lock() is waiting on the fairness queue. They should not
  8455. + * try all at once to call stdma_lock(), one is enough! For that, the
  8456. + * first one sets 'falcon_trying_lock', others that see that variable
  8457. + * set wait on the queue 'falcon_try_wait'.
  8458. + * Complicated, complicated.... Sigh...
  8459. + */
  8460. +
  8461. +static void falcon_get_lock( void )
  8462. +
  8463. +{
  8464. +    unsigned long    oldflags;
  8465. +    
  8466. +    if (IS_A_TT()) return;
  8467. +
  8468. +    save_flags(oldflags);
  8469. +    cli();
  8470. +    
  8471. +    while( falcon_got_lock && stdma_others_waiting() )
  8472. +        sleep_on( &falcon_fairness_wait );
  8473. +
  8474. +    if (!falcon_got_lock) {
  8475. +        if (!falcon_trying_lock) {
  8476. +            falcon_trying_lock = 1;
  8477. +            stdma_lock( scsi_falcon_intr, 0 );
  8478. +            falcon_got_lock = 1;
  8479. +            falcon_trying_lock = 0;
  8480. +            wake_up( &falcon_try_wait );
  8481. +        }
  8482. +        else {
  8483. +            sleep_on( &falcon_try_wait );
  8484. +        }
  8485. +    }    
  8486. +
  8487. +    restore_flags(oldflags);
  8488. +}
  8489. +
  8490. +
  8491. +/* This is the wrapper function for NCR5380_queue_command(). It just
  8492. + * trys to get the lock on the ST-DMA (see above) and then calls the
  8493. + * original function.
  8494. + */
  8495. +
  8496. +int atari_queue_command (Scsi_Cmnd *cmd, void (*done)(Scsi_Cmnd *))
  8497. +
  8498. +{
  8499. +    falcon_get_lock();
  8500. +    return( NCR5380_queue_command( cmd, done ) );
  8501. +}
  8502. +
  8503. +
  8504. +                   
  8505. +int atari_scsi_detect (int hostno)
  8506. +
  8507. +{    static int called = 0;
  8508. +    struct Scsi_Host *instance;
  8509. +
  8510. +    if (boot_info.machtype != MACH_ATARI || called)
  8511. +        return( 0 );
  8512. +    
  8513. +    atari_scsi_reg_read  = IS_A_TT() ? atari_scsi_tt_reg_read :
  8514. +                                       atari_scsi_falcon_reg_read;
  8515. +    atari_scsi_reg_write = IS_A_TT() ? atari_scsi_tt_reg_write :
  8516. +                                       atari_scsi_falcon_reg_write;
  8517. +
  8518. +    instance = scsi_register (hostno, sizeof (struct NCR5380_hostdata));
  8519. +    atari_scsi_host = instance;
  8520. +
  8521. +    NCR5380_init (instance);
  8522. +    instance->irq = 0;    /* not needed, but tested in NCR5380.c */
  8523. +
  8524. +    if (IS_A_TT()) {
  8525. +        
  8526. +        add_isr( IRQ_TT_MFP_SCSI, scsi_tt_intr, 0, NULL);
  8527. +        tt_mfp.active_edge |= 0x80;        /* SCSI int on L->H */
  8528. +        tt_mfp.int_en_a |= 0x80;        /* enabled */
  8529. +        tt_mfp.int_mk_a |= 0x80;        /* not masked */
  8530. +#ifdef REAL_DMA
  8531. +        /* On the TT, we got a second interrupt for DMA ready and DMA buserror.
  8532. +         * Since on DMA ready we get a "normal" interrupt, too, the service
  8533. +         * routine for the second int just checks for buserrs.
  8534. +         */
  8535. +        add_isr( IRQ_TT_MFP_SCSIDMA, scsi_dma_buserr, 0, NULL);
  8536. +        tt_mfp.active_edge &= ~0x20;    /* DMA int on H->L */
  8537. +        tt_mfp.int_en_b |= 0x80;        /* enabled */
  8538. +        tt_mfp.int_mk_b |= 0x80;        /* not masked */
  8539. +
  8540. +        tt_scsi_dma.dma_ctrl = 0;
  8541. +        atari_dma_residual = 0;
  8542. +#endif /* REAL_DMA */
  8543. +
  8544. +    }
  8545. +    else { /* ! IS_A_TT */
  8546. +        
  8547. +        /* Nothing to do for the interrupt: the ST-DMA is initialized
  8548. +         * already by atari_init_INTS()
  8549. +         */
  8550. +
  8551. +#ifdef REAL_DMA
  8552. +        atari_dma_residual = 0;
  8553. +        atari_dma_active = 0;
  8554. +#endif
  8555. +
  8556. +        /* Falcon's ST-DMA can work only in lower 16 MB, so
  8557. +         * unchecked_isa_dma has to be set. But... the high level
  8558. +         * codes allocates lots (!) of memory for buffers if this is
  8559. +         * done. So the values for sg_tablesize and cmd_per_lun get
  8560. +         * lowered a bit (you can leave this out if you have 16MB of
  8561. +         * ST-Ram).
  8562. +         */
  8563. +        atari_scsi_host->unchecked_isa_dma =
  8564. +        atari_scsi_host->hostt->unchecked_isa_dma = 1;
  8565. +#if I_HAVE_OVERRUNS == 3
  8566. +        atari_scsi_host->sg_tablesize =
  8567. +        atari_scsi_host->hostt->sg_tablesize = SG_NONE;
  8568. +#else
  8569. +        atari_scsi_host->sg_tablesize =
  8570. +        atari_scsi_host->hostt->sg_tablesize = 8;
  8571. +#endif
  8572. +        atari_scsi_host->hostt->cmd_per_lun = 8;
  8573. +    }
  8574. +    
  8575. +    printk( "scsi%d: options CAN_QUEUE=%d CMD_PER_LUN=%d SCATTERGATHER=%d",
  8576. +            instance->host_no, instance->hostt->can_queue,
  8577. +            instance->hostt->cmd_per_lun,
  8578. +            instance->hostt->sg_tablesize );
  8579. +    NCR5380_print_options (instance);
  8580. +    printk ("\n");
  8581. +
  8582. +    called = 1;
  8583. +
  8584. +    return( 1 );
  8585. +}
  8586. +
  8587. +int atari_scsi_reset( Scsi_Cmnd *cmd )
  8588. +
  8589. +{    int        rv;
  8590. +    
  8591. +    /* For doing the reset, SCSI interrupts must be disabled first,
  8592. +     * since the 5380 raises its IRQ line while _RST is active and we
  8593. +     * can't disable interrupts completely, since we need the timer.
  8594. +     */
  8595. +    
  8596. +    if (IS_A_TT())
  8597. +        tt_mfp.int_en_a &= ~0x80;
  8598. +    else
  8599. +        mfp.int_en_b &= ~0x80;
  8600. +    
  8601. +    rv = NCR5380_reset( cmd );
  8602. +
  8603. +    /* Re-enable ints and abort a maybe active DMA transfer */
  8604. +    if (IS_A_TT()) {
  8605. +#ifdef REAL_DMA
  8606. +        tt_scsi_dma.dma_ctrl = 0;
  8607. +#endif /* REAL_DMA */
  8608. +        tt_mfp.int_en_a |= 0x80;
  8609. +    }
  8610. +    else {
  8611. +#ifdef REAL_DMA
  8612. +        st_dma.dma_mode_status = 0x90;
  8613. +        atari_dma_active = 0;
  8614. +#endif /* REAL_DMA */
  8615. +        mfp.int_en_b |= 0x80;
  8616. +    }
  8617. +
  8618. +    return( rv );
  8619. +}
  8620. +
  8621. +    
  8622. +const char * atari_scsi_info( void )
  8623. +
  8624. +{    /* atari_scsi_detect() is verbose enough... */
  8625. +    static const char string[] = "";
  8626. +    return string;
  8627. +}
  8628. +
  8629. +
  8630. +#if defined(REAL_DMA) || defined(REAL_DMA_POLL) || defined(PSEUDO_DMA)
  8631. +
  8632. +unsigned long atari_scsi_dma_setup( struct Scsi_Host *instance, void *data,
  8633. +                                    unsigned long count, int dir )
  8634. +{
  8635. +    unsigned long addr = VTOP( data ),
  8636. +                  cando = atari_dma_xfer_len( count );
  8637. +
  8638. +#if (NDEBUG & NDEBUG_DMA)
  8639. +    printk ("scsi%d: setting up dma, data = %p, phys = %lx, count = %ld, cando = %ld, dir = %d\n",
  8640. +            instance->host_no, data, addr, count, cando, dir);
  8641. +#endif
  8642. +
  8643. +    atari_dma_startaddr = addr;    /* Needed for calculating residual later. */
  8644. +  
  8645. +    if (dir)
  8646. +        /* write: push any dirty cache out before sending it to the
  8647. +         * peripheral. (Must be done before DMA setup, since at least the
  8648. +         * ST-DMA begins to fill internal buffers right after setup.
  8649. +         */
  8650. +        cache_push( addr, cando );
  8651. +    else
  8652. +        /* read: invalidate any cache, may be altered after DMA without CPU
  8653. +         * knowledge
  8654. +         */
  8655. +        cache_clear( addr, cando );
  8656. +
  8657. +    if (cando == 0)
  8658. +        printk( "SCSI warning: DMA programed for 0 bytes !\n" );
  8659. +
  8660. +    if (IS_A_TT()) {
  8661. +    
  8662. +        tt_scsi_dma.dma_ctrl = dir;
  8663. +        SCSI_DMA_WRITE_P( dma_addr_hi, addr );
  8664. +        SCSI_DMA_WRITE_P( dma_cnt_hi, cando );
  8665. +        tt_scsi_dma.dma_ctrl = dir | 2;
  8666. +    }
  8667. +    else { /* ! IS_A_TT */
  8668. +  
  8669. +        /* set address */
  8670. +        SCSI_DMA_SETADR( addr );
  8671. +
  8672. +        /* toggle direction bit to clear FIFO and set DMA direction */
  8673. +        dir <<= 8;
  8674. +        st_dma.dma_mode_status = 0x90 | dir;
  8675. +        st_dma.dma_mode_status = 0x90 | (dir ^ 0x100);
  8676. +        st_dma.dma_mode_status = 0x90 | dir;
  8677. +        udelay(40);
  8678. +        st_dma.fdc_acces_seccount = cando >> 9;
  8679. +        udelay(40);
  8680. +        st_dma.dma_mode_status = 0x10 | dir;
  8681. +        udelay(40);
  8682. +        /* need not restore value of dir, only boolean value is tested */
  8683. +        atari_dma_active = 1;
  8684. +    }
  8685. +    
  8686. +    return( cando );
  8687. +}
  8688. +
  8689. +
  8690. +static long atari_scsi_dma_residual( struct Scsi_Host *instance )
  8691. +
  8692. +{
  8693. +    return( atari_dma_residual );
  8694. +}
  8695. +
  8696. +/* This function calculates the number of bytes that can be transferred
  8697. + * via DMA. On the TT, this is arbitrary, but on the Falcon we have to use
  8698. + * the ST-DMA chip. There are only multiples of 512 bytes possible and
  8699. + * max. 256*512 bytes :-( This means also, that defining READ_OVERRUNS is
  8700. + * not possible, since that would require to program the DMA for n*512 - 2
  8701. + * bytes.
  8702. + */
  8703. +
  8704. +static unsigned long atari_dma_xfer_len( unsigned long wanted_len )
  8705. +
  8706. +{
  8707. +    unsigned long    possible_len;
  8708. +
  8709. +    if (IS_A_TT())
  8710. +        /* TT SCSI DMA can transfer arbitrary #bytes */
  8711. +        return( wanted_len );
  8712. +    
  8713. +    /* ST DMA chip is stupid -- only multiples of 512 bytes! (and max.
  8714. +     * 255*512 bytes, but this should be enough)
  8715. +     */
  8716. +    possible_len =wanted_len & ~0x1ff;
  8717. +    if (possible_len > 255*512)
  8718. +        possible_len = 255*512;
  8719. +
  8720. +#if (NDEBUG & NDEBUG_DMA)
  8721. +    if (possible_len != wanted_len)
  8722. +        printk( "Sorry, must cut DMA transfer size to %ld bytes instead of %ld\n",
  8723. +                possible_len, wanted_len );
  8724. +#endif
  8725. +
  8726. +    return( possible_len );
  8727. +}
  8728. +
  8729. +
  8730. +#endif    /* REAL_DMA || REAL_DMA_POLL || PSEUDO_DMA */
  8731. +
  8732. +
  8733. +/* NCR5380 register access functions
  8734. + *
  8735. + * There are seperate functions for TT and Falcon, because the access
  8736. + * methods are quite different. The calling macros NCR5380_read and
  8737. + * NCR5380_write call these functions via function pointers.
  8738. + */
  8739. +
  8740. +static unsigned char atari_scsi_tt_reg_read( unsigned char reg )
  8741. +
  8742. +{
  8743. +    return( tt_scsi_regp[reg * 2] );
  8744. +}
  8745. +
  8746. +static void atari_scsi_tt_reg_write( unsigned char reg, unsigned char value )
  8747. +
  8748. +{
  8749. +    tt_scsi_regp[reg * 2] = value;
  8750. +}
  8751. +
  8752. +static unsigned char atari_scsi_falcon_reg_read( unsigned char reg )
  8753. +
  8754. +{
  8755. +    dma_wd.dma_mode_status= (u_short)(0x88 + reg);
  8756. +    return( (u_char)dma_wd.fdc_acces_seccount );
  8757. +}
  8758. +
  8759. +static void atari_scsi_falcon_reg_write( unsigned char reg, unsigned char value )
  8760. +
  8761. +{
  8762. +    dma_wd.dma_mode_status = (u_short)(0x88 + reg);
  8763. +    dma_wd.fdc_acces_seccount = (u_short)value;
  8764. +}
  8765. +
  8766. +
  8767. +#include "atari_NCR5380.c"
  8768. +
  8769. +#endif /* CONFIG_ATARI_*_SCSI */
  8770. diff -ubr -x RCS -x *.[ao] -x .depend -x .version -x .config -x System.map -x vmlinux -x bootstrap -x *~ -x config.old -x *.orig -x *.rej -x *# -x version.h -x autoconf.h --new-file linux-0.9pl3/drivers/scsi/scsi.c linux-0.9pl4/drivers/scsi/scsi.c
  8771. --- linux-0.9pl3/drivers/scsi/scsi.c    Sun Aug 14 10:30:49 1994
  8772. +++ linux-0.9pl4/drivers/scsi/scsi.c    Mon Nov  7 22:30:18 1994
  8773. @@ -26,7 +26,7 @@
  8774.  #include "constants.h"
  8775.  
  8776.  /*
  8777. -static const char RCSid[] = "$Header: /usr/src/linux/kernel/blk_drv/scsi/RCS/scsi.c,v 1.5 1993/09/24 12:45:18 drew Exp drew $";
  8778. +static const char RCSid[] = "$Header: /var/src/linux-0.9pl4/drivers/scsi/RCS/scsi.c,v 1.1 1994/11/08 03:29:28 hamish Exp hamish $";
  8779.  */
  8780.  
  8781.  /* Command groups 3 and 4 are reserved and should never be used.  */
  8782. @@ -603,13 +603,13 @@
  8783.        SCpnt->request.nr_sectors -= req->nr_sectors;
  8784.        req->current_nr_sectors = bh->b_size >> 9;
  8785.        req->buffer = bh->b_data;
  8786. -      SCpnt->request.waiting = NULL; /* Wait until whole thing done */
  8787. +      SCpnt->request.sem = NULL; /* Wait until whole thing done */
  8788.      } else
  8789.        req->dev = -1;
  8790.        
  8791.    } else {
  8792.      SCpnt->request.dev = 0xffff; /* Busy, but no request */
  8793. -    SCpnt->request.waiting = NULL;  /* And no one is waiting for the device either */
  8794. +    SCpnt->request.sem = NULL;  /* And no one is waiting for the device either */
  8795.    };
  8796.  
  8797.    SCpnt->use_sg = 0;  /* Reset the scatter-gather flag */
  8798. @@ -701,7 +701,7 @@
  8799.          SCpnt->request.nr_sectors -= req->nr_sectors;
  8800.          req->current_nr_sectors = bh->b_size >> 9;
  8801.          req->buffer = bh->b_data;
  8802. -        SCpnt->request.waiting = NULL; /* Wait until whole thing done */
  8803. +        SCpnt->request.sem = NULL; /* Wait until whole thing done */
  8804.        }
  8805.        else 
  8806.          {
  8807. @@ -710,7 +710,7 @@
  8808.          };
  8809.      } else {
  8810.        SCpnt->request.dev = 0xffff; /* Busy */
  8811. -      SCpnt->request.waiting = NULL;  /* And no one is waiting for this to complete */
  8812. +      SCpnt->request.sem = NULL;  /* And no one is waiting for this to complete */
  8813.      };
  8814.      restore_flags (flags);
  8815.      break;
  8816. @@ -1501,7 +1501,10 @@
  8817.  
  8818.      if(SCset){
  8819.        oldto = SCset->timeout - used;
  8820. +    if(timeout)
  8821.        SCset->timeout = timeout + used;
  8822. +    else
  8823. +      SCset->timeout = 0;
  8824.      };
  8825.  
  8826.      least = 0xffffffff;
  8827. @@ -1667,6 +1670,7 @@
  8828.            SCpnt->host = scsi_devices[i].host;
  8829.            SCpnt->target = scsi_devices[i].id;
  8830.            SCpnt->lun = scsi_devices[i].lun;
  8831. +          SCpnt->timeout = 0;
  8832.            SCpnt->index = i;
  8833.            SCpnt->request.dev = -1; /* Mark not busy */
  8834.            SCpnt->use_sg = 0;
  8835. diff -ubr -x RCS -x *.[ao] -x .depend -x .version -x .config -x System.map -x vmlinux -x bootstrap -x *~ -x config.old -x *.orig -x *.rej -x *# -x version.h -x autoconf.h --new-file linux-0.9pl3/drivers/scsi/scsi.h linux-0.9pl4/drivers/scsi/scsi.h
  8836. --- linux-0.9pl3/drivers/scsi/scsi.h    Sun Aug 14 10:30:46 1994
  8837. +++ linux-0.9pl4/drivers/scsi/scsi.h    Sat Nov  5 11:41:45 1994
  8838. @@ -452,7 +452,6 @@
  8839.  {
  8840.      struct request * req;
  8841.      struct buffer_head * bh;
  8842. -    struct task_struct * p;
  8843.  
  8844.      req = &SCpnt->request;
  8845.      req->errors = 0;
  8846. @@ -484,11 +483,8 @@
  8847.        return;
  8848.      };
  8849.      DEVICE_OFF(req->dev);
  8850. -    if ((p = req->waiting) != NULL) {
  8851. -        req->waiting = NULL;
  8852. -        p->state = TASK_RUNNING;
  8853. -        if (p->counter > current->counter)
  8854. -            need_resched = 1;
  8855. +    if (req->sem != NULL) {
  8856. +        up(req->sem);
  8857.      }
  8858.      req->dev = -1;
  8859.      wake_up(&scsi_devices[SCpnt->index].device_wait);
  8860. diff -ubr -x RCS -x *.[ao] -x .depend -x .version -x .config -x System.map -x vmlinux -x bootstrap -x *~ -x config.old -x *.orig -x *.rej -x *# -x version.h -x autoconf.h --new-file linux-0.9pl3/drivers/scsi/scsi_ioctl.c linux-0.9pl4/drivers/scsi/scsi_ioctl.c
  8861. --- linux-0.9pl3/drivers/scsi/scsi_ioctl.c    Sun Aug 14 10:30:49 1994
  8862. +++ linux-0.9pl4/drivers/scsi/scsi_ioctl.c    Sat Nov  5 11:50:28 1994
  8863. @@ -72,16 +72,12 @@
  8864.  static void scsi_ioctl_done (Scsi_Cmnd * SCpnt)
  8865.  {
  8866.    struct request * req;
  8867. -  struct task_struct * p;
  8868.  
  8869.    req = &SCpnt->request;
  8870.    req->dev = 0xfffe; /* Busy, but indicate request done */
  8871.  
  8872. -  if ((p = req->waiting) != NULL) {
  8873. -    req->waiting = NULL;
  8874. -    p->state = TASK_RUNNING;
  8875. -    if (p->counter > current->counter)
  8876. -      need_resched = 1;
  8877. +  if (req->sem != NULL) {
  8878. +    up(req->sem);
  8879.    }
  8880.  }
  8881.  
  8882. @@ -96,8 +92,10 @@
  8883.              MAX_RETRIES);
  8884.  
  8885.      if (SCpnt->request.dev != 0xfffe){
  8886. -      SCpnt->request.waiting = current;
  8887. -      current->state = TASK_UNINTERRUPTIBLE;
  8888. +      struct semaphore sem = MUTEX_LOCKED;
  8889. +      SCpnt->request.sem = &sem;
  8890. +      down(&sem);
  8891. +      /* Hmm.. Have to ask about this one */
  8892.        while (SCpnt->request.dev != 0xfffe) schedule();
  8893.      };
  8894.  
  8895. @@ -146,7 +144,7 @@
  8896.      Scsi_Cmnd * SCpnt;
  8897.      unsigned char opcode;
  8898.      int inlen, outlen, cmdlen;
  8899. -    int needed;
  8900. +    int needed, buf_needed;
  8901.      int result;
  8902.  
  8903.      if (!buffer)
  8904. @@ -158,11 +156,11 @@
  8905.      cmd_in = (char *) ( ((int *)buffer) + 2);
  8906.      opcode = get_fs_byte(cmd_in);
  8907.  
  8908. -    needed = (inlen > outlen ? inlen : outlen);
  8909. -    if(needed){
  8910. -      needed = (needed + 511) & ~511;
  8911. -      if (needed > MAX_BUF) needed = MAX_BUF;
  8912. -      buf = (char *) scsi_malloc(needed);
  8913. +    needed = buf_needed = (inlen > outlen ? inlen : outlen);
  8914. +    if(buf_needed){
  8915. +      buf_needed = (buf_needed + 511) & ~511;
  8916. +      if (buf_needed > MAX_BUF) buf_needed = MAX_BUF;
  8917. +      buf = (char *) scsi_malloc(buf_needed);
  8918.        if (!buf) return -ENOMEM;
  8919.      } else
  8920.        buf = NULL;
  8921. @@ -180,8 +178,10 @@
  8922.              MAX_RETRIES);
  8923.  
  8924.      if (SCpnt->request.dev != 0xfffe){
  8925. -      SCpnt->request.waiting = current;
  8926. -      current->state = TASK_UNINTERRUPTIBLE;
  8927. +      struct semaphore sem = MUTEX_LOCKED;
  8928. +      SCpnt->request.sem = &sem;
  8929. +      down(&sem);
  8930. +      /* Hmm.. Have to ask about this one */
  8931.        while (SCpnt->request.dev != 0xfffe) schedule();
  8932.      };
  8933.  
  8934. @@ -201,7 +201,7 @@
  8935.      };
  8936.      result = SCpnt->result;
  8937.      SCpnt->request.dev = -1;  /* Mark as not busy */
  8938. -    if (buf) scsi_free(buf, needed);
  8939. +    if (buf) scsi_free(buf, buf_needed);
  8940.      wake_up(&scsi_devices[SCpnt->index].device_wait);
  8941.      return result;
  8942.  #else
  8943. diff -ubr -x RCS -x *.[ao] -x .depend -x .version -x .config -x System.map -x vmlinux -x bootstrap -x *~ -x config.old -x *.orig -x *.rej -x *# -x version.h -x autoconf.h --new-file linux-0.9pl3/drivers/scsi/sd.c linux-0.9pl4/drivers/scsi/sd.c
  8944. --- linux-0.9pl3/drivers/scsi/sd.c    Sun Aug 14 10:30:50 1994
  8945. +++ linux-0.9pl4/drivers/scsi/sd.c    Sat Nov  5 11:41:47 1994
  8946. @@ -652,16 +652,12 @@
  8947.  static void sd_init_done (Scsi_Cmnd * SCpnt)
  8948.  {
  8949.    struct request * req;
  8950. -  struct task_struct * p;
  8951.  
  8952.    req = &SCpnt->request;
  8953.    req->dev = 0xfffe; /* Busy, but indicate request done */
  8954.  
  8955. -  if ((p = req->waiting) != NULL) {
  8956. -    req->waiting = NULL;
  8957. -    p->state = TASK_RUNNING;
  8958. -    if (p->counter > current->counter)
  8959. -      need_resched = 1;
  8960. +  if (req->sem != NULL) {
  8961. +    up(req->sem);
  8962.    }
  8963.  }
  8964.  
  8965. @@ -766,8 +762,10 @@
  8966.        while(SCpnt->request.dev != 0xfffe);
  8967.      else
  8968.        if (SCpnt->request.dev != 0xfffe){
  8969. -    SCpnt->request.waiting = current;
  8970. -    current->state = TASK_UNINTERRUPTIBLE;
  8971. +          struct semaphore sem = MUTEX_LOCKED;
  8972. +    SCpnt->request.sem = &sem;
  8973. +    down(&sem);
  8974. +    /* Hmm.. Have to ask about this one.. */
  8975.      while (SCpnt->request.dev != 0xfffe) schedule();
  8976.        };
  8977.  
  8978. diff -ubr -x RCS -x *.[ao] -x .depend -x .version -x .config -x System.map -x vmlinux -x bootstrap -x *~ -x config.old -x *.orig -x *.rej -x *# -x version.h -x autoconf.h --new-file linux-0.9pl3/drivers/scsi/sr.c linux-0.9pl4/drivers/scsi/sr.c
  8979. --- linux-0.9pl3/drivers/scsi/sr.c    Sun Aug 14 10:30:50 1994
  8980. +++ linux-0.9pl4/drivers/scsi/sr.c    Sat Nov  5 11:41:46 1994
  8981. @@ -634,16 +634,12 @@
  8982.  static void sr_init_done (Scsi_Cmnd * SCpnt)
  8983.  {
  8984.    struct request * req;
  8985. -  struct task_struct * p;
  8986.    
  8987.    req = &SCpnt->request;
  8988.    req->dev = 0xfffe; /* Busy, but indicate request done */
  8989.    
  8990. -  if ((p = req->waiting) != NULL) {
  8991. -    req->waiting = NULL;
  8992. -    p->state = TASK_RUNNING;
  8993. -    if (p->counter > current->counter)
  8994. -      need_resched = 1;
  8995. +  if (req->sem != NULL) {
  8996. +    up(req->sem);
  8997.    }
  8998.  }
  8999.  
  9000. @@ -673,8 +669,10 @@
  9001.        while(SCpnt->request.dev != 0xfffe);
  9002.      else
  9003.        if (SCpnt->request.dev != 0xfffe){
  9004. -    SCpnt->request.waiting = current;
  9005. -    current->state = TASK_UNINTERRUPTIBLE;
  9006. +          struct semaphore sem = MUTEX_LOCKED;
  9007. +    SCpnt->request.sem = &sem;
  9008. +    down(&sem);
  9009. +    /* Hmm.. Have to ask about this */
  9010.      while (SCpnt->request.dev != 0xfffe) schedule();
  9011.        };
  9012.      
  9013. diff -ubr -x RCS -x *.[ao] -x .depend -x .version -x .config -x System.map -x vmlinux -x bootstrap -x *~ -x config.old -x *.orig -x *.rej -x *# -x version.h -x autoconf.h --new-file linux-0.9pl3/drivers/scsi/sr_ioctl.c linux-0.9pl4/drivers/scsi/sr_ioctl.c
  9014. --- linux-0.9pl3/drivers/scsi/sr_ioctl.c    Sun Aug 14 10:30:49 1994
  9015. +++ linux-0.9pl4/drivers/scsi/sr_ioctl.c    Sat Nov  5 11:41:48 1994
  9016. @@ -21,16 +21,12 @@
  9017.  static void sr_ioctl_done(Scsi_Cmnd * SCpnt)
  9018.  {
  9019.    struct request * req;
  9020. -  struct task_struct * p;
  9021.    
  9022.    req = &SCpnt->request;
  9023.    req->dev = 0xfffe; /* Busy, but indicate request done */
  9024.    
  9025. -  if ((p = req->waiting) != NULL) {
  9026. -    req->waiting = NULL;
  9027. -    p->state = TASK_RUNNING;
  9028. -    if (p->counter > current->counter)
  9029. -      need_resched = 1;
  9030. +  if (req->sem != NULL) {
  9031. +    up(req->sem);
  9032.    }
  9033.  }
  9034.  
  9035. @@ -50,8 +46,10 @@
  9036.  
  9037.  
  9038.      if (SCpnt->request.dev != 0xfffe){
  9039. -      SCpnt->request.waiting = current;
  9040. -      current->state = TASK_UNINTERRUPTIBLE;
  9041. +      struct semaphore sem = MUTEX_LOCKED;
  9042. +      SCpnt->request.sem = &sem;
  9043. +      down(&sem);
  9044. +      /* Hmm.. Have to ask about this */
  9045.        while (SCpnt->request.dev != 0xfffe) schedule();
  9046.      };
  9047.  
  9048. diff -ubr -x RCS -x *.[ao] -x .depend -x .version -x .config -x System.map -x vmlinux -x bootstrap -x *~ -x config.old -x *.orig -x *.rej -x *# -x version.h -x autoconf.h --new-file linux-0.9pl3/fs/buffer.c linux-0.9pl4/fs/buffer.c
  9049. --- linux-0.9pl3/fs/buffer.c    Sun Aug 14 10:29:52 1994
  9050. +++ linux-0.9pl4/fs/buffer.c    Mon Nov  7 22:31:29 1994
  9051. @@ -48,6 +48,10 @@
  9052.  #ifdef CONFIG_MCD
  9053.  extern int check_mcd_media_change(int, int);
  9054.  #endif
  9055. +#ifdef CONFIG_ATARI_ACSI
  9056. +extern int check_acsi_media_change(int, int);
  9057. +extern int revalidate_acsidisk(int, int);
  9058. +#endif
  9059.  
  9060.  static int grow_buffers(int pri, int size);
  9061.  
  9062. @@ -257,6 +261,12 @@
  9063.          break;
  9064.  #endif
  9065.  
  9066. +#if defined(CONFIG_ATARI_ACSI)
  9067. +         case ACSI_MAJOR:
  9068. +        i = check_acsi_media_change(dev, 0);
  9069. +        break;
  9070. +#endif
  9071. +
  9072.       default:
  9073.          return;
  9074.      };
  9075. @@ -276,6 +286,11 @@
  9076.     all of the partitions that lie on the disk. */
  9077.      if (MAJOR(dev) == SCSI_DISK_MAJOR)
  9078.          revalidate_scsidisk(dev, 0);
  9079. +#endif
  9080. +#if defined(CONFIG_ATARI_ACSI)
  9081. +/* The same is true for ACSI removable harddisks... */
  9082. +    if (MAJOR(dev) == ACSI_MAJOR)
  9083. +        revalidate_acsidisk(dev, 0);
  9084.  #endif
  9085.  }
  9086.  
  9087. diff -ubr -x RCS -x *.[ao] -x .depend -x .version -x .config -x System.map -x vmlinux -x bootstrap -x *~ -x config.old -x *.orig -x *.rej -x *# -x version.h -x autoconf.h --new-file linux-0.9pl3/fs/minix/symlink.c linux-0.9pl4/fs/minix/symlink.c
  9088. --- linux-0.9pl3/fs/minix/symlink.c    Tue Sep 27 22:22:40 1994
  9089. +++ linux-0.9pl4/fs/minix/symlink.c    Mon Oct 10 16:47:50 1994
  9090. @@ -101,7 +101,6 @@
  9091.          i++;
  9092.          put_fs_byte(c,buffer++);
  9093.      }
  9094. -    put_fs_byte(0,buffer++); /* mark EOS */
  9095.      brelse(bh);
  9096.      return i;
  9097.  }
  9098. diff -ubr -x RCS -x *.[ao] -x .depend -x .version -x .config -x System.map -x vmlinux -x bootstrap -x *~ -x config.old -x *.orig -x *.rej -x *# -x version.h -x autoconf.h --new-file linux-0.9pl3/fs/nfs/Makefile linux-0.9pl4/fs/nfs/Makefile
  9099. --- linux-0.9pl3/fs/nfs/Makefile    Wed Dec 31 19:00:00 1969
  9100. +++ linux-0.9pl4/fs/nfs/Makefile    Mon Oct 10 16:48:25 1994
  9101. @@ -0,0 +1,27 @@
  9102. +#
  9103. +# Makefile for the linux nfs-filesystem routines.
  9104. +#
  9105. +# Note! Dependencies are done automagically by 'make dep', which also
  9106. +# removes any old dependencies. DON'T put your own dependencies here
  9107. +# unless it's something special (ie not a .c file).
  9108. +#
  9109. +# Note 2! The CFLAGS definitions are now in the main makefile...
  9110. +
  9111. +include ../../.config
  9112. +include ../../MakeVars
  9113. +
  9114. +OBJS=    proc.o sock.o inode.o file.o dir.o \
  9115. +    symlink.o mmap.o
  9116. +
  9117. +nfs.o: $(OBJS)
  9118. +    $(LD) -r -o nfs.o $(OBJS)
  9119. +
  9120. +dep:
  9121. +    $(CPP) -M *.c > .depend
  9122. +
  9123. +#
  9124. +# include a dependency file if one exists
  9125. +#
  9126. +ifeq (.depend,$(wildcard .depend))
  9127. +include .depend
  9128. +endif
  9129. diff -ubr -x RCS -x *.[ao] -x .depend -x .version -x .config -x System.map -x vmlinux -x bootstrap -x *~ -x config.old -x *.orig -x *.rej -x *# -x version.h -x autoconf.h --new-file linux-0.9pl3/fs/nfs/dir.c linux-0.9pl4/fs/nfs/dir.c
  9130. --- linux-0.9pl3/fs/nfs/dir.c    Wed Dec 31 19:00:00 1969
  9131. +++ linux-0.9pl4/fs/nfs/dir.c    Wed Dec  1 07:44:15 1993
  9132. @@ -0,0 +1,606 @@
  9133. +/*
  9134. + *  linux/fs/nfs/dir.c
  9135. + *
  9136. + *  Copyright (C) 1992  Rick Sladkey
  9137. + *
  9138. + *  nfs directory handling functions
  9139. + */
  9140. +
  9141. +#include <linux/sched.h>
  9142. +#include <linux/errno.h>
  9143. +#include <linux/stat.h>
  9144. +#include <linux/nfs_fs.h>
  9145. +#include <linux/fcntl.h>
  9146. +#include <linux/string.h>
  9147. +#include <linux/kernel.h>
  9148. +#include <linux/malloc.h>
  9149. +#include <linux/mm.h>
  9150. +
  9151. +#include <asm/segment.h>    /* for fs functions */
  9152. +
  9153. +static int nfs_dir_read(struct inode *, struct file *filp, char *buf,
  9154. +            int count);
  9155. +static int nfs_readdir(struct inode *, struct file *, struct dirent *, int);
  9156. +static int nfs_lookup(struct inode *dir, const char *name, int len,
  9157. +              struct inode **result);
  9158. +static int nfs_create(struct inode *dir, const char *name, int len, int mode,
  9159. +              struct inode **result);
  9160. +static int nfs_mkdir(struct inode *dir, const char *name, int len, int mode);
  9161. +static int nfs_rmdir(struct inode *dir, const char *name, int len);
  9162. +static int nfs_unlink(struct inode *dir, const char *name, int len);
  9163. +static int nfs_symlink(struct inode *inode, const char *name, int len,
  9164. +               const char *symname);
  9165. +static int nfs_link(struct inode *oldinode, struct inode *dir,
  9166. +            const char *name, int len);
  9167. +static int nfs_mknod(struct inode *dir, const char *name, int len, int mode,
  9168. +             int rdev);
  9169. +static int nfs_rename(struct inode *old_dir, const char *old_name,
  9170. +              int old_len, struct inode *new_dir, const char *new_name,
  9171. +              int new_len);
  9172. +
  9173. +static struct file_operations nfs_dir_operations = {
  9174. +    NULL,            /* lseek - default */
  9175. +    nfs_dir_read,        /* read - bad */
  9176. +    NULL,            /* write - bad */
  9177. +    nfs_readdir,        /* readdir */
  9178. +    NULL,            /* select - default */
  9179. +    NULL,            /* ioctl - default */
  9180. +    NULL,            /* mmap */
  9181. +    NULL,            /* no special open code */
  9182. +    NULL,            /* no special release code */
  9183. +    NULL            /* fsync */
  9184. +};
  9185. +
  9186. +struct inode_operations nfs_dir_inode_operations = {
  9187. +    &nfs_dir_operations,    /* default directory file-ops */
  9188. +    nfs_create,        /* create */
  9189. +    nfs_lookup,        /* lookup */
  9190. +    nfs_link,        /* link */
  9191. +    nfs_unlink,        /* unlink */
  9192. +    nfs_symlink,        /* symlink */
  9193. +    nfs_mkdir,        /* mkdir */
  9194. +    nfs_rmdir,        /* rmdir */
  9195. +    nfs_mknod,        /* mknod */
  9196. +    nfs_rename,        /* rename */
  9197. +    NULL,            /* readlink */
  9198. +    NULL,            /* follow_link */
  9199. +    NULL,            /* bmap */
  9200. +    NULL,            /* truncate */
  9201. +    NULL            /* permission */
  9202. +};
  9203. +
  9204. +static int nfs_dir_read(struct inode *inode, struct file *filp, char *buf,
  9205. +            int count)
  9206. +{
  9207. +    return -EISDIR;
  9208. +}
  9209. +
  9210. +/*
  9211. + * We need to do caching of directory entries to prevent an
  9212. + * incredible amount of RPC traffic.  Only the most recent open
  9213. + * directory is cached.  This seems sufficient for most purposes.
  9214. + * Technically, we ought to flush the cache on close but this is
  9215. + * not a problem in practice.
  9216. + */
  9217. +
  9218. +static int nfs_readdir(struct inode *inode, struct file *filp,
  9219. +               struct dirent *dirent, int count)
  9220. +{
  9221. +    static int c_dev = 0;
  9222. +    static int c_ino;
  9223. +    static int c_size;
  9224. +    static struct nfs_entry *c_entry = NULL;
  9225. +
  9226. +    int result;
  9227. +    int i;
  9228. +    struct nfs_entry *entry;
  9229. +
  9230. +    if (!inode || !S_ISDIR(inode->i_mode)) {
  9231. +        printk("nfs_readdir: inode is NULL or not a directory\n");
  9232. +        return -EBADF;
  9233. +    }
  9234. +
  9235. +    /* initialize cache memory if it hasn't been used before */
  9236. +
  9237. +    if (c_entry == NULL) {
  9238. +        i = sizeof (struct nfs_entry)*NFS_READDIR_CACHE_SIZE;
  9239. +        c_entry = (struct nfs_entry *) kmalloc(i, GFP_KERNEL);
  9240. +        for (i = 0; i < NFS_READDIR_CACHE_SIZE; i++) {
  9241. +            c_entry[i].name = (char *) kmalloc(NFS_MAXNAMLEN + 1,
  9242. +                GFP_KERNEL);
  9243. +        }
  9244. +    }
  9245. +    entry = NULL;
  9246. +
  9247. +    /* try to find it in the cache */
  9248. +
  9249. +    if (inode->i_dev == c_dev && inode->i_ino == c_ino) {
  9250. +        for (i = 0; i < c_size; i++) {
  9251. +            if (filp->f_pos == c_entry[i].cookie) {
  9252. +                if (i == c_size - 1) {
  9253. +                    if (c_entry[i].eof)
  9254. +                        return 0;
  9255. +                }
  9256. +                else
  9257. +                    entry = c_entry + i + 1;
  9258. +                break;
  9259. +            }
  9260. +        }
  9261. +    }
  9262. +
  9263. +    /* if we didn't find it in the cache, revert to an nfs call */
  9264. +
  9265. +    if (!entry) {
  9266. +        result = nfs_proc_readdir(NFS_SERVER(inode), NFS_FH(inode),
  9267. +            filp->f_pos, NFS_READDIR_CACHE_SIZE, c_entry);
  9268. +        if (result < 0) {
  9269. +            c_dev = 0;
  9270. +            return result;
  9271. +        }
  9272. +        if (result > 0) {
  9273. +            c_dev = inode->i_dev;
  9274. +            c_ino = inode->i_ino;
  9275. +            c_size = result;
  9276. +            entry = c_entry + 0;
  9277. +        }
  9278. +    }
  9279. +
  9280. +    /* if we found it in the cache or from an nfs call, return results */
  9281. +
  9282. +    if (entry) {
  9283. +        i = strlen(entry->name);
  9284. +        memcpy_tofs(dirent->d_name, entry->name, i + 1);
  9285. +        put_fs_long(entry->fileid, &dirent->d_ino);
  9286. +        put_fs_word(i, &dirent->d_reclen);
  9287. +        filp->f_pos = entry->cookie;
  9288. +        return i;
  9289. +    }
  9290. +    return 0;
  9291. +}
  9292. +
  9293. +/*
  9294. + * Lookup caching is a big win for performance but this is just
  9295. + * a trial to see how well it works on a small scale.
  9296. + * For example, bash does a lookup on ".." 13 times for each path
  9297. + * element when running pwd.  Yes, hard to believe but true.
  9298. + * Try pwd in a filesystem mounted with noac.
  9299. + *
  9300. + * It trades a little cpu time and memory for a lot of network bandwidth.
  9301. + * Since the cache is not hashed yet, it is a good idea not to make it too
  9302. + * large because every lookup looks through the entire cache even
  9303. + * though most of them will fail.
  9304. + */
  9305. +
  9306. +static struct nfs_lookup_cache_entry {
  9307. +    int dev;
  9308. +    int inode;
  9309. +    char filename[NFS_MAXNAMLEN + 1];
  9310. +    struct nfs_fh fhandle;
  9311. +    struct nfs_fattr fattr;
  9312. +    int expiration_date;
  9313. +} nfs_lookup_cache[NFS_LOOKUP_CACHE_SIZE];
  9314. +
  9315. +static struct nfs_lookup_cache_entry *nfs_lookup_cache_index(struct inode *dir,
  9316. +                                 const char *filename)
  9317. +{
  9318. +    struct nfs_lookup_cache_entry *entry;
  9319. +    int i;
  9320. +
  9321. +    for (i = 0; i < NFS_LOOKUP_CACHE_SIZE; i++) {
  9322. +        entry = nfs_lookup_cache + i;
  9323. +        if (entry->dev == dir->i_dev && entry->inode == dir->i_ino
  9324. +            && !strncmp(filename, entry->filename, NFS_MAXNAMLEN))
  9325. +            return entry;
  9326. +    }
  9327. +    return NULL;
  9328. +}
  9329. +
  9330. +static int nfs_lookup_cache_lookup(struct inode *dir, const char *filename,
  9331. +                   struct nfs_fh *fhandle,
  9332. +                   struct nfs_fattr *fattr)
  9333. +{
  9334. +    static int nfs_lookup_cache_in_use = 0;
  9335. +
  9336. +    struct nfs_lookup_cache_entry *entry;
  9337. +
  9338. +    if (!nfs_lookup_cache_in_use) {
  9339. +        memset(nfs_lookup_cache, 0, sizeof(nfs_lookup_cache));
  9340. +        nfs_lookup_cache_in_use = 1;
  9341. +    }
  9342. +    if ((entry = nfs_lookup_cache_index(dir, filename))) {
  9343. +        if (jiffies > entry->expiration_date) {
  9344. +            entry->dev = 0;
  9345. +            return 0;
  9346. +        }
  9347. +        *fhandle = entry->fhandle;
  9348. +        *fattr = entry->fattr;
  9349. +        return 1;
  9350. +    }
  9351. +    return 0;
  9352. +}
  9353. +
  9354. +static void nfs_lookup_cache_add(struct inode *dir, const char *filename,
  9355. +                 struct nfs_fh *fhandle,
  9356. +                 struct nfs_fattr *fattr)
  9357. +{
  9358. +    static int nfs_lookup_cache_pos = 0;
  9359. +    struct nfs_lookup_cache_entry *entry;
  9360. +
  9361. +    /* compensate for bug in SGI NFS server */
  9362. +    if (fattr->size == -1 || fattr->uid == -1 || fattr->gid == -1
  9363. +        || fattr->atime.seconds == -1 || fattr->mtime.seconds == -1)
  9364. +        return;
  9365. +    if (!(entry = nfs_lookup_cache_index(dir, filename))) {
  9366. +        entry = nfs_lookup_cache + nfs_lookup_cache_pos++;
  9367. +        if (nfs_lookup_cache_pos == NFS_LOOKUP_CACHE_SIZE)
  9368. +            nfs_lookup_cache_pos = 0;
  9369. +    }
  9370. +    entry->dev = dir->i_dev;
  9371. +    entry->inode = dir->i_ino;
  9372. +    strcpy(entry->filename, filename);
  9373. +    entry->fhandle = *fhandle;
  9374. +    entry->fattr = *fattr;
  9375. +    entry->expiration_date = jiffies + (S_ISDIR(fattr->mode)
  9376. +        ? NFS_SERVER(dir)->acdirmax : NFS_SERVER(dir)->acregmax);
  9377. +}
  9378. +
  9379. +static void nfs_lookup_cache_remove(struct inode *dir, struct inode *inode,
  9380. +                    const char *filename)
  9381. +{
  9382. +    struct nfs_lookup_cache_entry *entry;
  9383. +    int dev;
  9384. +    int fileid;
  9385. +    int i;
  9386. +
  9387. +    if (inode) {
  9388. +        dev = inode->i_dev;
  9389. +        fileid = inode->i_ino;
  9390. +    }
  9391. +    else if ((entry = nfs_lookup_cache_index(dir, filename))) {
  9392. +        dev = entry->dev;
  9393. +        fileid = entry->fattr.fileid;
  9394. +    }
  9395. +    else
  9396. +        return;
  9397. +    for (i = 0; i < NFS_LOOKUP_CACHE_SIZE; i++) {
  9398. +        entry = nfs_lookup_cache + i;
  9399. +        if (entry->dev == dev && entry->fattr.fileid == fileid)
  9400. +            entry->dev = 0;
  9401. +    }
  9402. +}
  9403. +
  9404. +static void nfs_lookup_cache_refresh(struct inode *file,
  9405. +                     struct nfs_fattr *fattr)
  9406. +{
  9407. +    struct nfs_lookup_cache_entry *entry;
  9408. +    int dev = file->i_dev;
  9409. +    int fileid = file->i_ino;
  9410. +    int i;
  9411. +
  9412. +    for (i = 0; i < NFS_LOOKUP_CACHE_SIZE; i++) {
  9413. +        entry = nfs_lookup_cache + i;
  9414. +        if (entry->dev == dev && entry->fattr.fileid == fileid)
  9415. +            entry->fattr = *fattr;
  9416. +    }
  9417. +}
  9418. +
  9419. +static int nfs_lookup(struct inode *dir, const char *__name, int len,
  9420. +              struct inode **result)
  9421. +{
  9422. +    struct nfs_fh fhandle;
  9423. +    struct nfs_fattr fattr;
  9424. +    char name[len > NFS_MAXNAMLEN? 1 : len+1];
  9425. +    int error;
  9426. +
  9427. +    *result = NULL;
  9428. +    if (!dir || !S_ISDIR(dir->i_mode)) {
  9429. +        printk("nfs_lookup: inode is NULL or not a directory\n");
  9430. +        iput(dir);
  9431. +        return -ENOENT;
  9432. +    }
  9433. +    if (len > NFS_MAXNAMLEN) {
  9434. +        iput(dir);
  9435. +        return -ENAMETOOLONG;
  9436. +    }
  9437. +    memcpy(name,__name,len);
  9438. +    name[len] = '\0';
  9439. +    if (len == 1 && name[0] == '.') { /* cheat for "." */
  9440. +        *result = dir;
  9441. +        return 0;
  9442. +    }
  9443. +    if ((NFS_SERVER(dir)->flags & NFS_MOUNT_NOAC)
  9444. +        || !nfs_lookup_cache_lookup(dir, name, &fhandle, &fattr)) {
  9445. +        if ((error = nfs_proc_lookup(NFS_SERVER(dir), NFS_FH(dir),
  9446. +            name, &fhandle, &fattr))) {
  9447. +            iput(dir);
  9448. +            return error;
  9449. +        }
  9450. +        nfs_lookup_cache_add(dir, name, &fhandle, &fattr);
  9451. +    }
  9452. +    if (!(*result = nfs_fhget(dir->i_sb, &fhandle, &fattr))) {
  9453. +        iput(dir);
  9454. +        return -EACCES;
  9455. +    }
  9456. +    iput(dir);
  9457. +    return 0;
  9458. +}
  9459. +
  9460. +static int nfs_create(struct inode *dir, const char *name, int len, int mode,
  9461. +              struct inode **result)
  9462. +{
  9463. +    struct nfs_sattr sattr;
  9464. +    struct nfs_fattr fattr;
  9465. +    struct nfs_fh fhandle;
  9466. +    int error;
  9467. +
  9468. +    *result = NULL;
  9469. +    if (!dir || !S_ISDIR(dir->i_mode)) {
  9470. +        printk("nfs_create: inode is NULL or not a directory\n");
  9471. +        iput(dir);
  9472. +        return -ENOENT;
  9473. +    }
  9474. +    if (len > NFS_MAXNAMLEN) {
  9475. +        iput(dir);
  9476. +        return -ENAMETOOLONG;
  9477. +    }
  9478. +    sattr.mode = mode;
  9479. +    sattr.uid = sattr.gid = sattr.size = (unsigned) -1;
  9480. +    sattr.atime.seconds = sattr.mtime.seconds = (unsigned) -1;
  9481. +    if ((error = nfs_proc_create(NFS_SERVER(dir), NFS_FH(dir),
  9482. +        name, &sattr, &fhandle, &fattr))) {
  9483. +        iput(dir);
  9484. +        return error;
  9485. +    }
  9486. +    if (!(*result = nfs_fhget(dir->i_sb, &fhandle, &fattr))) {
  9487. +        iput(dir);
  9488. +        return -EACCES;
  9489. +    }
  9490. +    nfs_lookup_cache_add(dir, name, &fhandle, &fattr);
  9491. +    iput(dir);
  9492. +    return 0;
  9493. +}
  9494. +
  9495. +static int nfs_mknod(struct inode *dir, const char *name, int len,
  9496. +             int mode, int rdev)
  9497. +{
  9498. +    struct nfs_sattr sattr;
  9499. +    struct nfs_fattr fattr;
  9500. +    struct nfs_fh fhandle;
  9501. +    int error;
  9502. +
  9503. +    if (!dir || !S_ISDIR(dir->i_mode)) {
  9504. +        printk("nfs_mknod: inode is NULL or not a directory\n");
  9505. +        iput(dir);
  9506. +        return -ENOENT;
  9507. +    }
  9508. +    if (len > NFS_MAXNAMLEN) {
  9509. +        iput(dir);
  9510. +        return -ENAMETOOLONG;
  9511. +    }
  9512. +    sattr.mode = mode;
  9513. +    sattr.uid = sattr.gid = (unsigned) -1;
  9514. +    if (S_ISCHR(mode) || S_ISBLK(mode))
  9515. +        sattr.size = rdev; /* get out your barf bag */
  9516. +    else
  9517. +        sattr.size = (unsigned) -1;
  9518. +    sattr.atime.seconds = sattr.mtime.seconds = (unsigned) -1;
  9519. +    error = nfs_proc_create(NFS_SERVER(dir), NFS_FH(dir),
  9520. +        name, &sattr, &fhandle, &fattr);
  9521. +    if (!error)
  9522. +        nfs_lookup_cache_add(dir, name, &fhandle, &fattr);
  9523. +    iput(dir);
  9524. +    return error;
  9525. +}
  9526. +
  9527. +static int nfs_mkdir(struct inode *dir, const char *name, int len, int mode)
  9528. +{
  9529. +    struct nfs_sattr sattr;
  9530. +    struct nfs_fattr fattr;
  9531. +    struct nfs_fh fhandle;
  9532. +    int error;
  9533. +
  9534. +    if (!dir || !S_ISDIR(dir->i_mode)) {
  9535. +        printk("nfs_mkdir: inode is NULL or not a directory\n");
  9536. +        iput(dir);
  9537. +        return -ENOENT;
  9538. +    }
  9539. +    if (len > NFS_MAXNAMLEN) {
  9540. +        iput(dir);
  9541. +        return -ENAMETOOLONG;
  9542. +    }
  9543. +    sattr.mode = mode;
  9544. +    sattr.uid = sattr.gid = sattr.size = (unsigned) -1;
  9545. +    sattr.atime.seconds = sattr.mtime.seconds = (unsigned) -1;
  9546. +    error = nfs_proc_mkdir(NFS_SERVER(dir), NFS_FH(dir),
  9547. +        name, &sattr, &fhandle, &fattr);
  9548. +    if (!error)
  9549. +        nfs_lookup_cache_add(dir, name, &fhandle, &fattr);
  9550. +    iput(dir);
  9551. +    return error;
  9552. +}
  9553. +
  9554. +static int nfs_rmdir(struct inode *dir, const char *name, int len)
  9555. +{
  9556. +    int error;
  9557. +
  9558. +    if (!dir || !S_ISDIR(dir->i_mode)) {
  9559. +        printk("nfs_rmdir: inode is NULL or not a directory\n");
  9560. +        iput(dir);
  9561. +        return -ENOENT;
  9562. +    }
  9563. +    if (len > NFS_MAXNAMLEN) {
  9564. +        iput(dir);
  9565. +        return -ENAMETOOLONG;
  9566. +    }
  9567. +    error = nfs_proc_rmdir(NFS_SERVER(dir), NFS_FH(dir), name);
  9568. +    if (!error)
  9569. +        nfs_lookup_cache_remove(dir, NULL, name);
  9570. +    iput(dir);
  9571. +    return error;
  9572. +}
  9573. +
  9574. +static int nfs_unlink(struct inode *dir, const char *name, int len)
  9575. +{
  9576. +    int error;
  9577. +
  9578. +    if (!dir || !S_ISDIR(dir->i_mode)) {
  9579. +        printk("nfs_unlink: inode is NULL or not a directory\n");
  9580. +        iput(dir);
  9581. +        return -ENOENT;
  9582. +    }
  9583. +    if (len > NFS_MAXNAMLEN) {
  9584. +        iput(dir);
  9585. +        return -ENAMETOOLONG;
  9586. +    }
  9587. +    error = nfs_proc_remove(NFS_SERVER(dir), NFS_FH(dir), name);
  9588. +    if (!error)
  9589. +        nfs_lookup_cache_remove(dir, NULL, name);
  9590. +    iput(dir);
  9591. +    return error;
  9592. +}
  9593. +
  9594. +static int nfs_symlink(struct inode *dir, const char *name, int len,
  9595. +               const char *symname)
  9596. +{
  9597. +    struct nfs_sattr sattr;
  9598. +    int error;
  9599. +
  9600. +    if (!dir || !S_ISDIR(dir->i_mode)) {
  9601. +        printk("nfs_symlink: inode is NULL or not a directory\n");
  9602. +        iput(dir);
  9603. +        return -ENOENT;
  9604. +    }
  9605. +    if (len > NFS_MAXNAMLEN) {
  9606. +        iput(dir);
  9607. +        return -ENAMETOOLONG;
  9608. +    }
  9609. +    if (strlen(symname) > NFS_MAXPATHLEN) {
  9610. +        iput(dir);
  9611. +        return -ENAMETOOLONG;
  9612. +    }
  9613. +    sattr.mode = S_IFLNK | S_IRWXUGO; /* SunOS 4.1.2 crashes without this! */
  9614. +    sattr.uid = sattr.gid = sattr.size = (unsigned) -1;
  9615. +    sattr.atime.seconds = sattr.mtime.seconds = (unsigned) -1;
  9616. +    error = nfs_proc_symlink(NFS_SERVER(dir), NFS_FH(dir),
  9617. +        name, symname, &sattr);
  9618. +    iput(dir);
  9619. +    return error;
  9620. +}
  9621. +
  9622. +static int nfs_link(struct inode *oldinode, struct inode *dir,
  9623. +            const char *name, int len)
  9624. +{
  9625. +    int error;
  9626. +
  9627. +    if (!oldinode) {
  9628. +        printk("nfs_link: old inode is NULL\n");
  9629. +        iput(oldinode);
  9630. +        iput(dir);
  9631. +        return -ENOENT;
  9632. +    }
  9633. +    if (!dir || !S_ISDIR(dir->i_mode)) {
  9634. +        printk("nfs_link: dir is NULL or not a directory\n");
  9635. +        iput(oldinode);
  9636. +        iput(dir);
  9637. +        return -ENOENT;
  9638. +    }
  9639. +    if (len > NFS_MAXNAMLEN) {
  9640. +        iput(oldinode);
  9641. +        iput(dir);
  9642. +        return -ENAMETOOLONG;
  9643. +    }
  9644. +    error = nfs_proc_link(NFS_SERVER(oldinode), NFS_FH(oldinode),
  9645. +        NFS_FH(dir), name);
  9646. +    if (!error)
  9647. +        nfs_lookup_cache_remove(dir, oldinode, NULL);
  9648. +    iput(oldinode);
  9649. +    iput(dir);
  9650. +    return error;
  9651. +}
  9652. +
  9653. +static int nfs_rename(struct inode *old_dir, const char *old_name, int old_len,
  9654. +              struct inode *new_dir, const char *new_name, int new_len)
  9655. +{
  9656. +    int error;
  9657. +
  9658. +    if (!old_dir || !S_ISDIR(old_dir->i_mode)) {
  9659. +        printk("nfs_rename: old inode is NULL or not a directory\n");
  9660. +        iput(old_dir);
  9661. +        iput(new_dir);
  9662. +        return -ENOENT;
  9663. +    }
  9664. +    if (!new_dir || !S_ISDIR(new_dir->i_mode)) {
  9665. +        printk("nfs_rename: new inode is NULL or not a directory\n");
  9666. +        iput(old_dir);
  9667. +        iput(new_dir);
  9668. +        return -ENOENT;
  9669. +    }
  9670. +    if (old_len > NFS_MAXNAMLEN || new_len > NFS_MAXNAMLEN) {
  9671. +        iput(old_dir);
  9672. +        iput(new_dir);
  9673. +        return -ENAMETOOLONG;
  9674. +    }
  9675. +    error = nfs_proc_rename(NFS_SERVER(old_dir),
  9676. +        NFS_FH(old_dir), old_name,
  9677. +        NFS_FH(new_dir), new_name);
  9678. +    if (!error) {
  9679. +        nfs_lookup_cache_remove(old_dir, NULL, old_name);
  9680. +        nfs_lookup_cache_remove(new_dir, NULL, new_name);
  9681. +    }
  9682. +    iput(old_dir);
  9683. +    iput(new_dir);
  9684. +    return error;
  9685. +}
  9686. +
  9687. +/*
  9688. + * Many nfs protocol calls return the new file attributes after
  9689. + * an operation.  Here we update the inode to reflect the state
  9690. + * of the server's inode.
  9691. + */
  9692. +
  9693. +void nfs_refresh_inode(struct inode *inode, struct nfs_fattr *fattr)
  9694. +{
  9695. +    int was_empty;
  9696. +
  9697. +    if (!inode || !fattr) {
  9698. +        printk("nfs_refresh_inode: inode or fattr is NULL\n");
  9699. +        return;
  9700. +    }
  9701. +    if (inode->i_ino != fattr->fileid) {
  9702. +        printk("nfs_refresh_inode: inode number mismatch\n");
  9703. +        return;
  9704. +    }
  9705. +    was_empty = inode->i_mode == 0;
  9706. +    inode->i_mode = fattr->mode;
  9707. +    inode->i_nlink = fattr->nlink;
  9708. +    inode->i_uid = fattr->uid;
  9709. +    inode->i_gid = fattr->gid;
  9710. +    inode->i_size = fattr->size;
  9711. +    inode->i_blksize = fattr->blocksize;
  9712. +    if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode))
  9713. +        inode->i_rdev = fattr->rdev;
  9714. +    else
  9715. +        inode->i_rdev = 0;
  9716. +    inode->i_blocks = fattr->blocks;
  9717. +    inode->i_atime = fattr->atime.seconds;
  9718. +    inode->i_mtime = fattr->mtime.seconds;
  9719. +    inode->i_ctime = fattr->ctime.seconds;
  9720. +    if (was_empty) {
  9721. +        if (S_ISREG(inode->i_mode))
  9722. +            inode->i_op = &nfs_file_inode_operations;
  9723. +        else if (S_ISDIR(inode->i_mode))
  9724. +            inode->i_op = &nfs_dir_inode_operations;
  9725. +        else if (S_ISLNK(inode->i_mode))
  9726. +            inode->i_op = &nfs_symlink_inode_operations;
  9727. +        else if (S_ISCHR(inode->i_mode))
  9728. +            inode->i_op = &chrdev_inode_operations;
  9729. +        else if (S_ISBLK(inode->i_mode))
  9730. +            inode->i_op = &blkdev_inode_operations;
  9731. +        else if (S_ISFIFO(inode->i_mode))
  9732. +            init_fifo(inode);
  9733. +        else
  9734. +            inode->i_op = NULL;
  9735. +    }
  9736. +    nfs_lookup_cache_refresh(inode, fattr);
  9737. +}
  9738. +
  9739. diff -ubr -x RCS -x *.[ao] -x .depend -x .version -x .config -x System.map -x vmlinux -x bootstrap -x *~ -x config.old -x *.orig -x *.rej -x *# -x version.h -x autoconf.h --new-file linux-0.9pl3/fs/nfs/file.c linux-0.9pl4/fs/nfs/file.c
  9740. --- linux-0.9pl3/fs/nfs/file.c    Wed Dec 31 19:00:00 1969
  9741. +++ linux-0.9pl4/fs/nfs/file.c    Wed Dec  1 07:44:15 1993
  9742. @@ -0,0 +1,163 @@
  9743. +/*
  9744. + *  linux/fs/nfs/file.c
  9745. + *
  9746. + *  Copyright (C) 1992  Rick Sladkey
  9747. + *
  9748. + *  nfs regular file handling functions
  9749. + */
  9750. +
  9751. +#include <asm/segment.h>
  9752. +#include <asm/system.h>
  9753. +
  9754. +#include <linux/sched.h>
  9755. +#include <linux/kernel.h>
  9756. +#include <linux/errno.h>
  9757. +#include <linux/fcntl.h>
  9758. +#include <linux/stat.h>
  9759. +#include <linux/mm.h>
  9760. +#include <linux/nfs_fs.h>
  9761. +#include <linux/malloc.h>
  9762. +
  9763. +static int nfs_file_read(struct inode *, struct file *, char *, int);
  9764. +static int nfs_file_write(struct inode *, struct file *, char *, int);
  9765. +static int nfs_fsync(struct inode *, struct file *);
  9766. +extern int nfs_mmap(struct inode * inode, struct file * file,
  9767. +          unsigned long addr, size_t len, int prot, unsigned long off);
  9768. +
  9769. +static struct file_operations nfs_file_operations = {
  9770. +    NULL,            /* lseek - default */
  9771. +    nfs_file_read,        /* read */
  9772. +    nfs_file_write,        /* write */
  9773. +    NULL,            /* readdir - bad */
  9774. +    NULL,            /* select - default */
  9775. +    NULL,            /* ioctl - default */
  9776. +    nfs_mmap,        /* mmap */
  9777. +    NULL,            /* no special open is needed */
  9778. +    NULL,            /* release */
  9779. +    nfs_fsync,        /* fsync */
  9780. +};
  9781. +
  9782. +struct inode_operations nfs_file_inode_operations = {
  9783. +    &nfs_file_operations,    /* default file operations */
  9784. +    NULL,            /* create */
  9785. +    NULL,            /* lookup */
  9786. +    NULL,            /* link */
  9787. +    NULL,            /* unlink */
  9788. +    NULL,            /* symlink */
  9789. +    NULL,            /* mkdir */
  9790. +    NULL,            /* rmdir */
  9791. +    NULL,            /* mknod */
  9792. +    NULL,            /* rename */
  9793. +    NULL,            /* readlink */
  9794. +    NULL,            /* follow_link */
  9795. +    NULL,            /* bmap */
  9796. +    NULL            /* truncate */
  9797. +};
  9798. +
  9799. +static int nfs_fsync(struct inode *inode, struct file *file)
  9800. +{
  9801. +    return 0;
  9802. +}
  9803. +
  9804. +static int nfs_file_read(struct inode *inode, struct file *file, char *buf,
  9805. +             int count)
  9806. +{
  9807. +    int result;
  9808. +    int hunk;
  9809. +    int i;
  9810. +    int n;
  9811. +    struct nfs_fattr fattr;
  9812. +    char *data;
  9813. +    off_t pos;
  9814. +
  9815. +    if (!inode) {
  9816. +        printk("nfs_file_read: inode = NULL\n");
  9817. +        return -EINVAL;
  9818. +    }
  9819. +    if (!S_ISREG(inode->i_mode)) {
  9820. +        printk("nfs_file_read: read from non-file, mode %07o\n",
  9821. +            inode->i_mode);
  9822. +        return -EINVAL;
  9823. +    }
  9824. +    pos = file->f_pos;
  9825. +    if (file->f_pos + count > inode->i_size)
  9826. +        count = inode->i_size - pos;
  9827. +    if (count <= 0)
  9828. +        return 0;
  9829. +    n = NFS_SERVER(inode)->rsize;
  9830. +    data = (char *) kmalloc(n, GFP_KERNEL);
  9831. +    for (i = 0; i < count; i += n) {
  9832. +        hunk = count - i;
  9833. +        if (hunk > n)
  9834. +            hunk = n;
  9835. +        result = nfs_proc_read(NFS_SERVER(inode), NFS_FH(inode), 
  9836. +            pos, hunk, data, &fattr);
  9837. +        if (result < 0) {
  9838. +            kfree_s(data, n);
  9839. +            return result;
  9840. +        }
  9841. +        memcpy_tofs(buf, data, result);
  9842. +        pos += result;
  9843. +        buf += result;
  9844. +        if (result < n) {
  9845. +            i += result;
  9846. +            break;
  9847. +        }
  9848. +    }
  9849. +    file->f_pos = pos;
  9850. +    kfree_s(data, n);
  9851. +    nfs_refresh_inode(inode, &fattr);
  9852. +    return i;
  9853. +}
  9854. +
  9855. +static int nfs_file_write(struct inode *inode, struct file *file, char *buf,
  9856. +              int count)
  9857. +{
  9858. +    int result;
  9859. +    int hunk;
  9860. +    int i;
  9861. +    int n;
  9862. +    struct nfs_fattr fattr;
  9863. +    char *data;
  9864. +    int pos;
  9865. +
  9866. +    if (!inode) {
  9867. +        printk("nfs_file_write: inode = NULL\n");
  9868. +        return -EINVAL;
  9869. +    }
  9870. +    if (!S_ISREG(inode->i_mode)) {
  9871. +        printk("nfs_file_write: write to non-file, mode %07o\n",
  9872. +            inode->i_mode);
  9873. +        return -EINVAL;
  9874. +    }
  9875. +    if (count <= 0)
  9876. +        return 0;
  9877. +    pos = file->f_pos;
  9878. +    if (file->f_flags & O_APPEND)
  9879. +        pos = inode->i_size;
  9880. +    n = NFS_SERVER(inode)->wsize;
  9881. +    data = (char *) kmalloc(n, GFP_KERNEL);
  9882. +    for (i = 0; i < count; i += n) {
  9883. +        hunk = count - i;
  9884. +        if (hunk >= n)
  9885. +            hunk = n;
  9886. +        memcpy_fromfs(data, buf, hunk);
  9887. +        result = nfs_proc_write(NFS_SERVER(inode), NFS_FH(inode), 
  9888. +            pos, hunk, data, &fattr);
  9889. +        if (result < 0) {
  9890. +            kfree_s(data, n);
  9891. +            return result;
  9892. +        }
  9893. +        pos += hunk;
  9894. +        buf += hunk;
  9895. +        if (hunk < n) {
  9896. +            i += hunk;
  9897. +            break;
  9898. +        }
  9899. +    }
  9900. +    file->f_pos = pos;
  9901. +    kfree_s(data, n);
  9902. +    nfs_refresh_inode(inode, &fattr);
  9903. +    return i;
  9904. +}
  9905. +
  9906. diff -ubr -x RCS -x *.[ao] -x .depend -x .version -x .config -x System.map -x vmlinux -x bootstrap -x *~ -x config.old -x *.orig -x *.rej -x *# -x version.h -x autoconf.h --new-file linux-0.9pl3/fs/nfs/inode.c linux-0.9pl4/fs/nfs/inode.c
  9907. --- linux-0.9pl3/fs/nfs/inode.c    Wed Dec 31 19:00:00 1969
  9908. +++ linux-0.9pl4/fs/nfs/inode.c    Wed Dec  1 07:44:15 1993
  9909. @@ -0,0 +1,233 @@
  9910. +/*
  9911. + *  linux/fs/nfs/inode.c
  9912. + *
  9913. + *  Copyright (C) 1992  Rick Sladkey
  9914. + *
  9915. + *  nfs inode and superblock handling functions
  9916. + */
  9917. +
  9918. +#include <asm/system.h>
  9919. +#include <asm/segment.h>
  9920. +
  9921. +#include <linux/sched.h>
  9922. +#include <linux/nfs_fs.h>
  9923. +#include <linux/kernel.h>
  9924. +#include <linux/mm.h>
  9925. +#include <linux/string.h>
  9926. +#include <linux/stat.h>
  9927. +#include <linux/errno.h>
  9928. +#include <linux/locks.h>
  9929. +
  9930. +extern int close_fp(struct file *filp, unsigned int fd);
  9931. +
  9932. +static int nfs_notify_change(int, struct inode *);
  9933. +static void nfs_put_inode(struct inode *);
  9934. +static void nfs_put_super(struct super_block *);
  9935. +static void nfs_statfs(struct super_block *, struct statfs *);
  9936. +
  9937. +static struct super_operations nfs_sops = { 
  9938. +    NULL,            /* read inode */
  9939. +    nfs_notify_change,    /* notify change */
  9940. +    NULL,            /* write inode */
  9941. +    nfs_put_inode,        /* put inode */
  9942. +    nfs_put_super,        /* put superblock */
  9943. +    NULL,            /* write superblock */
  9944. +    nfs_statfs,        /* stat filesystem */
  9945. +    NULL
  9946. +};
  9947. +
  9948. +static void nfs_put_inode(struct inode * inode)
  9949. +{
  9950. +    clear_inode(inode);
  9951. +}
  9952. +
  9953. +void nfs_put_super(struct super_block *sb)
  9954. +{
  9955. +        /* No locks should be open on this, so 0 should be safe as a fd. */
  9956. +    close_fp(sb->u.nfs_sb.s_server.file, 0);
  9957. +    lock_super(sb);
  9958. +    sb->s_dev = 0;
  9959. +    unlock_super(sb);
  9960. +}
  9961. +
  9962. +/*
  9963. + * The way this works is that the mount process passes a structure
  9964. + * in the data argument which contains an open socket to the NFS
  9965. + * server and the root file handle obtained from the server's mount
  9966. + * daemon.  We stash theses away in the private superblock fields.
  9967. + * Later we can add other mount parameters like caching values.
  9968. + */
  9969. +
  9970. +struct super_block *nfs_read_super(struct super_block *sb, void *raw_data,
  9971. +                   int silent)
  9972. +{
  9973. +    struct nfs_mount_data *data = (struct nfs_mount_data *) raw_data;
  9974. +    struct nfs_server *server;
  9975. +    unsigned int fd;
  9976. +    struct file *filp;
  9977. +    dev_t dev = sb->s_dev;
  9978. +
  9979. +    if (!data) {
  9980. +        printk("nfs_read_super: missing data argument\n");
  9981. +        sb->s_dev = 0;
  9982. +        return NULL;
  9983. +    }
  9984. +    fd = data->fd;
  9985. +    if (data->version != NFS_MOUNT_VERSION) {
  9986. +        printk("nfs warning: mount version %s than kernel\n",
  9987. +            data->version < NFS_MOUNT_VERSION ? "older" : "newer");
  9988. +    }
  9989. +    if (fd >= NR_OPEN || !(filp = current->filp[fd])) {
  9990. +        printk("nfs_read_super: invalid file descriptor\n");
  9991. +        sb->s_dev = 0;
  9992. +        return NULL;
  9993. +    }
  9994. +    if (!S_ISSOCK(filp->f_inode->i_mode)) {
  9995. +        printk("nfs_read_super: not a socket\n");
  9996. +        sb->s_dev = 0;
  9997. +        return NULL;
  9998. +    }
  9999. +    filp->f_count++;
  10000. +    lock_super(sb);
  10001. +    sb->s_blocksize = 1024; /* XXX */
  10002. +    sb->s_blocksize_bits = 10;
  10003. +    sb->s_magic = NFS_SUPER_MAGIC;
  10004. +    sb->s_dev = dev;
  10005. +    sb->s_op = &nfs_sops;
  10006. +    server = &sb->u.nfs_sb.s_server;
  10007. +    server->file = filp;
  10008. +    server->lock = 0;
  10009. +    server->wait = NULL;
  10010. +    server->flags = data->flags;
  10011. +    server->rsize = data->rsize;
  10012. +    if (server->rsize <= 0)
  10013. +        server->rsize = NFS_DEF_FILE_IO_BUFFER_SIZE;
  10014. +    else if (server->rsize >= NFS_MAX_FILE_IO_BUFFER_SIZE)
  10015. +        server->rsize = NFS_MAX_FILE_IO_BUFFER_SIZE;
  10016. +    server->wsize = data->wsize;
  10017. +    if (server->wsize <= 0)
  10018. +        server->wsize = NFS_DEF_FILE_IO_BUFFER_SIZE;
  10019. +    else if (server->wsize >= NFS_MAX_FILE_IO_BUFFER_SIZE)
  10020. +        server->wsize = NFS_MAX_FILE_IO_BUFFER_SIZE;
  10021. +    server->timeo = data->timeo*HZ/10;
  10022. +    server->retrans = data->retrans;
  10023. +    server->acregmin = data->acregmin*HZ;
  10024. +    server->acregmax = data->acregmax*HZ;
  10025. +    server->acdirmin = data->acdirmin*HZ;
  10026. +    server->acdirmax = data->acdirmax*HZ;
  10027. +    strcpy(server->hostname, data->hostname);
  10028. +    sb->u.nfs_sb.s_root = data->root;
  10029. +    unlock_super(sb);
  10030. +    if (!(sb->s_mounted = nfs_fhget(sb, &data->root, NULL))) {
  10031. +        sb->s_dev = 0;
  10032. +        printk("nfs_read_super: get root inode failed\n");
  10033. +        return NULL;
  10034. +    }
  10035. +    return sb;
  10036. +}
  10037. +
  10038. +void nfs_statfs(struct super_block *sb, struct statfs *buf)
  10039. +{
  10040. +    int error;
  10041. +    struct nfs_fsinfo res;
  10042. +
  10043. +    put_fs_long(NFS_SUPER_MAGIC, &buf->f_type);
  10044. +    error = nfs_proc_statfs(&sb->u.nfs_sb.s_server, &sb->u.nfs_sb.s_root,
  10045. +        &res);
  10046. +    if (error) {
  10047. +        printk("nfs_statfs: statfs error = %d\n", -error);
  10048. +        res.bsize = res.blocks = res.bfree = res.bavail = 0;
  10049. +    }
  10050. +    put_fs_long(res.bsize, &buf->f_bsize);
  10051. +    put_fs_long(res.blocks, &buf->f_blocks);
  10052. +    put_fs_long(res.bfree, &buf->f_bfree);
  10053. +    put_fs_long(res.bavail, &buf->f_bavail);
  10054. +    put_fs_long(0, &buf->f_files);
  10055. +    put_fs_long(0, &buf->f_ffree);
  10056. +    /* We should really try to interrogate the remote server to find
  10057. +       it's maximum name length here */
  10058. +    put_fs_long(NAME_MAX, &buf->f_namelen);
  10059. +}
  10060. +
  10061. +/*
  10062. + * This is our own version of iget that looks up inodes by file handle
  10063. + * instead of inode number.  We use this technique instead of using
  10064. + * the vfs read_inode function because there is no way to pass the
  10065. + * file handle or current attributes into the read_inode function.
  10066. + * We just have to be careful not to subvert iget's special handling
  10067. + * of mount points.
  10068. + */
  10069. +
  10070. +struct inode *nfs_fhget(struct super_block *sb, struct nfs_fh *fhandle,
  10071. +            struct nfs_fattr *fattr)
  10072. +{
  10073. +    struct nfs_fattr newfattr;
  10074. +    int error;
  10075. +    struct inode *inode;
  10076. +
  10077. +    if (!sb) {
  10078. +        printk("nfs_fhget: super block is NULL\n");
  10079. +        return NULL;
  10080. +    }
  10081. +    if (!fattr) {
  10082. +        error = nfs_proc_getattr(&sb->u.nfs_sb.s_server, fhandle,
  10083. +            &newfattr);
  10084. +        if (error) {
  10085. +            printk("nfs_fhget: getattr error = %d\n", -error);
  10086. +            return NULL;
  10087. +        }
  10088. +        fattr = &newfattr;
  10089. +    }
  10090. +    if (!(inode = iget(sb, fattr->fileid))) {
  10091. +        printk("nfs_fhget: iget failed\n");
  10092. +        return NULL;
  10093. +    }
  10094. +    if (inode->i_dev == sb->s_dev) {
  10095. +        if (inode->i_ino != fattr->fileid) {
  10096. +            printk("nfs_fhget: unexpected inode from iget\n");
  10097. +            return inode;
  10098. +        }
  10099. +        *NFS_FH(inode) = *fhandle;
  10100. +        nfs_refresh_inode(inode, fattr);
  10101. +    }
  10102. +    return inode;
  10103. +}
  10104. +
  10105. +int nfs_notify_change(int flags, struct inode *inode)
  10106. +{
  10107. +    struct nfs_sattr sattr;
  10108. +    struct nfs_fattr fattr;
  10109. +    int error;
  10110. +
  10111. +    if (flags & NOTIFY_MODE)
  10112. +        sattr.mode = inode->i_mode;
  10113. +    else
  10114. +        sattr.mode = (unsigned) -1;
  10115. +    if (flags & NOTIFY_UIDGID) {
  10116. +        sattr.uid = inode->i_uid;
  10117. +        sattr.gid = inode->i_gid;
  10118. +    }
  10119. +    else
  10120. +        sattr.uid = sattr.gid = (unsigned) -1;
  10121. +    if (flags & NOTIFY_SIZE)
  10122. +        sattr.size = S_ISREG(inode->i_mode) ? inode->i_size : -1;
  10123. +    else
  10124. +        sattr.size = (unsigned) -1;
  10125. +    if (flags & NOTIFY_TIME) {
  10126. +        sattr.mtime.seconds = inode->i_mtime;
  10127. +        sattr.mtime.useconds = 0;
  10128. +        sattr.atime.seconds = inode->i_atime;
  10129. +        sattr.atime.useconds = 0;
  10130. +    }
  10131. +    else {
  10132. +        sattr.mtime.seconds = sattr.mtime.useconds = (unsigned) -1;
  10133. +        sattr.atime.seconds = sattr.atime.useconds = (unsigned) -1;
  10134. +    }
  10135. +    error = nfs_proc_setattr(NFS_SERVER(inode), NFS_FH(inode),
  10136. +        &sattr, &fattr);
  10137. +    if (!error)
  10138. +        nfs_refresh_inode(inode, &fattr);
  10139. +    inode->i_dirt = 0;
  10140. +    return error;
  10141. +}
  10142. +
  10143. diff -ubr -x RCS -x *.[ao] -x .depend -x .version -x .config -x System.map -x vmlinux -x bootstrap -x *~ -x config.old -x *.orig -x *.rej -x *# -x version.h -x autoconf.h --new-file linux-0.9pl3/fs/nfs/mmap.c linux-0.9pl4/fs/nfs/mmap.c
  10144. --- linux-0.9pl3/fs/nfs/mmap.c    Wed Dec 31 19:00:00 1969
  10145. +++ linux-0.9pl4/fs/nfs/mmap.c    Mon Oct 10 16:48:26 1994
  10146. @@ -0,0 +1,161 @@
  10147. +/*
  10148. + *    fs/nfs/mmap.c    by Jon Tombs 15 Aug 1993
  10149. + *
  10150. + * This code is from
  10151. + *    linux/mm/mmap.c which was written by obz, Linus and Eric
  10152. + * and
  10153. + *    linux/mm/memory.c  by Linus Torvalds and others
  10154. + *
  10155. + *    Copyright (C) 1993
  10156. + *
  10157. + */
  10158. +#include <linux/stat.h>
  10159. +#include <linux/sched.h>
  10160. +#include <linux/kernel.h>
  10161. +#include <linux/mm.h>
  10162. +#include <linux/shm.h>
  10163. +#include <linux/errno.h>
  10164. +#include <linux/mman.h>
  10165. +#include <linux/string.h>
  10166. +#include <linux/malloc.h>
  10167. +#include <linux/nfs_fs.h>
  10168. +
  10169. +#include <asm/segment.h>
  10170. +#include <asm/system.h>
  10171. +
  10172. +extern int share_page(struct vm_area_struct * area, struct task_struct * tsk,
  10173. +    struct inode * inode, unsigned long address, unsigned long error_code,
  10174. +    unsigned long newpage);
  10175. +
  10176. +extern unsigned long put_page(struct task_struct * tsk,unsigned long page,
  10177. +    unsigned long address,int prot);
  10178. +
  10179. +static void nfs_file_mmap_nopage(int error_code, struct vm_area_struct * area,
  10180. +                unsigned long address);
  10181. +
  10182. +extern void file_mmap_free(struct vm_area_struct * area);
  10183. +extern int file_mmap_share(struct vm_area_struct * from, struct vm_area_struct * to,
  10184. +                unsigned long address);
  10185. +
  10186. +struct vm_operations_struct nfs_file_mmap = {
  10187. +    NULL,            /* open */
  10188. +    file_mmap_free,        /* close */
  10189. +    nfs_file_mmap_nopage,    /* nopage */
  10190. +    NULL,            /* wppage */
  10191. +    file_mmap_share,    /* share */
  10192. +    NULL,            /* unmap */
  10193. +};
  10194. +
  10195. +
  10196. +/* This is used for a general mmap of a nfs file */
  10197. +int nfs_mmap(struct inode * inode, struct file * file,
  10198. +    unsigned long addr, size_t len, int prot, unsigned long off)
  10199. +{
  10200. +    struct vm_area_struct * mpnt;
  10201. +
  10202. +    if (prot & PAGE_RW)    /* only PAGE_COW or read-only supported now */
  10203. +        return -EINVAL;
  10204. +    if (off & (inode->i_sb->s_blocksize - 1))
  10205. +        return -EINVAL;
  10206. +    if (!inode->i_sb || !S_ISREG(inode->i_mode))
  10207. +        return -EACCES;
  10208. +    if (!IS_RDONLY(inode)) {
  10209. +        inode->i_atime = CURRENT_TIME;
  10210. +        inode->i_dirt = 1;
  10211. +    }
  10212. +
  10213. +    mpnt = (struct vm_area_struct * ) kmalloc(sizeof(struct vm_area_struct), GFP_KERNEL);
  10214. +    if (!mpnt)
  10215. +        return -ENOMEM;
  10216. +
  10217. +    unmap_page_range(addr, len);
  10218. +    mpnt->vm_task = current;
  10219. +    mpnt->vm_start = addr;
  10220. +    mpnt->vm_end = addr + len;
  10221. +    mpnt->vm_page_prot = prot;
  10222. +    mpnt->vm_share = NULL;
  10223. +    mpnt->vm_inode = inode;
  10224. +    inode->i_count++;
  10225. +    mpnt->vm_offset = off;
  10226. +    mpnt->vm_ops = &nfs_file_mmap;
  10227. +    insert_vm_struct(current, mpnt);
  10228. +    merge_segments(current->mmap, NULL, NULL);
  10229. +    return 0;
  10230. +}
  10231. +
  10232. +
  10233. +static void nfs_file_mmap_nopage(int error_code, struct vm_area_struct * area,
  10234. +                unsigned long address)
  10235. +{
  10236. +    struct inode * inode = area->vm_inode;
  10237. +    unsigned int clear;
  10238. +    unsigned long page;
  10239. +    unsigned long tmp;
  10240. +    int n;
  10241. +    int i;
  10242. +    int pos;
  10243. +    struct nfs_fattr fattr;
  10244. +
  10245. +    address &= PAGE_MASK;
  10246. +    pos = address - area->vm_start + area->vm_offset;
  10247. +
  10248. +    page = get_free_page(GFP_KERNEL);
  10249. +    if (share_page(area, area->vm_task, inode, address, error_code, page)) {
  10250. +        ++area->vm_task->min_flt;
  10251. +        return;
  10252. +    }
  10253. +
  10254. +    ++area->vm_task->maj_flt;
  10255. +    if (!page) {
  10256. +        oom(current);
  10257. +        put_page(area->vm_task, BAD_PAGE, address, PAGE_PRIVATE);
  10258. +        return;
  10259. +    }
  10260. +
  10261. +    clear = 0;
  10262. +    if (address + PAGE_SIZE > area->vm_end) {
  10263. +        clear = address + PAGE_SIZE - area->vm_end;
  10264. +    }
  10265. +
  10266. +    n = NFS_SERVER(inode)->rsize; /* what we can read in one go */
  10267. +
  10268. +    for (i = 0; i < (PAGE_SIZE - clear); i += n) {
  10269. +        int hunk, result;
  10270. +
  10271. +        hunk = PAGE_SIZE - i;
  10272. +        if (hunk > n)
  10273. +            hunk = n;
  10274. +        result = nfs_proc_read(NFS_SERVER(inode), NFS_FH(inode),
  10275. +            pos, hunk, (char *) (page + i), &fattr);
  10276. +        if (result < 0)
  10277. +            break;
  10278. +        pos += result;
  10279. +        if (result < n) {
  10280. +            i += result;
  10281. +            break;
  10282. +        }
  10283. +    }
  10284. +
  10285. +#ifdef doweneedthishere
  10286. +    nfs_refresh_inode(inode, &fattr);
  10287. +#endif
  10288. +
  10289. +#if defined (__i386__)
  10290. +    if (!(error_code & PAGE_RW))
  10291. +#elif defined (__mc68000__)
  10292. +    if (!(error_code & 1))    /* ????? */
  10293. +#endif
  10294. +    {
  10295. +        if (share_page(area, area->vm_task, inode, address, error_code, page))
  10296. +            return;
  10297. +    }
  10298. +
  10299. +    tmp = page + PAGE_SIZE;
  10300. +    while (clear--) {
  10301. +        *(char *)--tmp = 0;
  10302. +    }
  10303. +    if (put_page(area->vm_task,page,address,area->vm_page_prot))
  10304. +        return;
  10305. +    free_page(page);
  10306. +    oom(current);
  10307. +}
  10308. diff -ubr -x RCS -x *.[ao] -x .depend -x .version -x .config -x System.map -x vmlinux -x bootstrap -x *~ -x config.old -x *.orig -x *.rej -x *# -x version.h -x autoconf.h --new-file linux-0.9pl3/fs/nfs/proc.c linux-0.9pl4/fs/nfs/proc.c
  10309. --- linux-0.9pl3/fs/nfs/proc.c    Wed Dec 31 19:00:00 1969
  10310. +++ linux-0.9pl4/fs/nfs/proc.c    Mon Feb 14 05:48:36 1994
  10311. @@ -0,0 +1,873 @@
  10312. +/*
  10313. + *  linux/fs/nfs/proc.c
  10314. + *
  10315. + *  Copyright (C) 1992, 1993, 1994  Rick Sladkey
  10316. + *
  10317. + *  OS-independent nfs remote procedure call functions
  10318. + */
  10319. +
  10320. +/*
  10321. + * Defining NFS_PROC_DEBUG causes a lookup of a file named
  10322. + * "xyzzy" to toggle debugging.  Just cd to an NFS-mounted
  10323. + * filesystem and type 'ls xyzzy' to turn on debugging.
  10324. + */
  10325. +
  10326. +#if 0
  10327. +#define NFS_PROC_DEBUG
  10328. +#endif
  10329. +
  10330. +#include <linux/config.h>
  10331. +#include <linux/param.h>
  10332. +#include <linux/sched.h>
  10333. +#include <linux/mm.h>
  10334. +#include <linux/nfs_fs.h>
  10335. +#include <linux/utsname.h>
  10336. +#include <linux/errno.h>
  10337. +#include <linux/string.h>
  10338. +#include <linux/in.h>
  10339. +
  10340. +#ifdef NFS_PROC_DEBUG
  10341. +
  10342. +static int proc_debug = 0;
  10343. +#define PRINTK(format, args...) \
  10344. +    do {                        \
  10345. +        if (proc_debug)                \
  10346. +            printk(format , ## args);    \
  10347. +    } while (0)
  10348. +
  10349. +#else /* !NFS_PROC_DEBUG */
  10350. +
  10351. +#define PRINTK(format, args...) do ; while (0)
  10352. +
  10353. +#endif /* !NFS_PROC_DEBUG */
  10354. +
  10355. +static int *nfs_rpc_header(int *p, int procedure, int ruid);
  10356. +static int *nfs_rpc_verify(int *p);
  10357. +static int nfs_stat_to_errno(int stat);
  10358. +
  10359. +/*
  10360. + * Our memory allocation and release functions.
  10361. + */
  10362. +
  10363. +static inline int *nfs_rpc_alloc(void)
  10364. +{
  10365. +    return (int *) __get_free_page(GFP_KERNEL);
  10366. +}
  10367. +
  10368. +static inline void nfs_rpc_free(int *p)
  10369. +{
  10370. +    free_page((long) p);
  10371. +}
  10372. +
  10373. +/*
  10374. + * Here are a bunch of xdr encode/decode functions that convert
  10375. + * between machine dependent and xdr data formats.
  10376. + */
  10377. +
  10378. +static inline int *xdr_encode_fhandle(int *p, struct nfs_fh *fhandle)
  10379. +{
  10380. +    *((struct nfs_fh *) p) = *fhandle;
  10381. +    p += (sizeof (*fhandle) + 3) >> 2;
  10382. +    return p;
  10383. +}
  10384. +
  10385. +static inline int *xdr_decode_fhandle(int *p, struct nfs_fh *fhandle)
  10386. +{
  10387. +    *fhandle = *((struct nfs_fh *) p);
  10388. +    p += (sizeof (*fhandle) + 3) >> 2;
  10389. +    return p;
  10390. +}
  10391. +
  10392. +static inline int *xdr_encode_string(int *p, const char *string)
  10393. +{
  10394. +    int len, quadlen;
  10395. +    
  10396. +    len = strlen(string);
  10397. +    quadlen = (len + 3) >> 2;
  10398. +    *p++ = htonl(len);
  10399. +    memcpy((char *) p, string, len);
  10400. +    memset(((char *) p) + len, '\0', (quadlen << 2) - len);
  10401. +    p += quadlen;
  10402. +    return p;
  10403. +}
  10404. +
  10405. +static inline int *xdr_decode_string(int *p, char *string, int maxlen)
  10406. +{
  10407. +    unsigned int len;
  10408. +
  10409. +    len = ntohl(*p++);
  10410. +    if (len > maxlen)
  10411. +        return NULL;
  10412. +    memcpy(string, (char *) p, len);
  10413. +    string[len] = '\0';
  10414. +    p += (len + 3) >> 2;
  10415. +    return p;
  10416. +}
  10417. +
  10418. +static inline int *xdr_encode_data(int *p, char *data, int len)
  10419. +{
  10420. +    int quadlen;
  10421. +    
  10422. +    quadlen = (len + 3) >> 2;
  10423. +    *p++ = htonl(len);
  10424. +    memcpy((char *) p, data, len);
  10425. +    memset(((char *) p) + len, '\0', (quadlen << 2) - len);
  10426. +    p += quadlen;
  10427. +    return p;
  10428. +}
  10429. +
  10430. +static inline int *xdr_decode_data(int *p, char *data, int *lenp, int maxlen)
  10431. +{
  10432. +    unsigned int len;
  10433. +
  10434. +    len = *lenp = ntohl(*p++);
  10435. +    if (len > maxlen)
  10436. +        return NULL;
  10437. +    memcpy(data, (char *) p, len);
  10438. +    p += (len + 3) >> 2;
  10439. +    return p;
  10440. +}
  10441. +
  10442. +static int *xdr_decode_fattr(int *p, struct nfs_fattr *fattr)
  10443. +{
  10444. +    fattr->type = (enum nfs_ftype) ntohl(*p++);
  10445. +    fattr->mode = ntohl(*p++);
  10446. +    fattr->nlink = ntohl(*p++);
  10447. +    fattr->uid = ntohl(*p++);
  10448. +    fattr->gid = ntohl(*p++);
  10449. +    fattr->size = ntohl(*p++);
  10450. +    fattr->blocksize = ntohl(*p++);
  10451. +    fattr->rdev = ntohl(*p++);
  10452. +    fattr->blocks = ntohl(*p++);
  10453. +    fattr->fsid = ntohl(*p++);
  10454. +    fattr->fileid = ntohl(*p++);
  10455. +    fattr->atime.seconds = ntohl(*p++);
  10456. +    fattr->atime.useconds = ntohl(*p++);
  10457. +    fattr->mtime.seconds = ntohl(*p++);
  10458. +    fattr->mtime.useconds = ntohl(*p++);
  10459. +    fattr->ctime.seconds = ntohl(*p++);
  10460. +    fattr->ctime.useconds = ntohl(*p++);
  10461. +    return p;
  10462. +}
  10463. +
  10464. +static int *xdr_encode_sattr(int *p, struct nfs_sattr *sattr)
  10465. +{
  10466. +    *p++ = htonl(sattr->mode);
  10467. +    *p++ = htonl(sattr->uid);
  10468. +    *p++ = htonl(sattr->gid);
  10469. +    *p++ = htonl(sattr->size);
  10470. +    *p++ = htonl(sattr->atime.seconds);
  10471. +    *p++ = htonl(sattr->atime.useconds);
  10472. +    *p++ = htonl(sattr->mtime.seconds);
  10473. +    *p++ = htonl(sattr->mtime.useconds);
  10474. +    return p;
  10475. +}
  10476. +
  10477. +static int *xdr_decode_entry(int *p, struct nfs_entry *entry)
  10478. +{
  10479. +    entry->fileid = ntohl(*p++);
  10480. +    if (!(p = xdr_decode_string(p, entry->name, NFS_MAXNAMLEN)))
  10481. +        return NULL;
  10482. +    entry->cookie = ntohl(*p++);
  10483. +    entry->eof = 0;
  10484. +    return p;
  10485. +}
  10486. +
  10487. +static int *xdr_decode_fsinfo(int *p, struct nfs_fsinfo *res)
  10488. +{
  10489. +    res->tsize = ntohl(*p++);
  10490. +    res->bsize = ntohl(*p++);
  10491. +    res->blocks = ntohl(*p++);
  10492. +    res->bfree = ntohl(*p++);
  10493. +    res->bavail = ntohl(*p++);
  10494. +    return p;
  10495. +}
  10496. +
  10497. +/*
  10498. + * One function for each procedure in the NFS protocol.
  10499. + */
  10500. +
  10501. +int nfs_proc_getattr(struct nfs_server *server, struct nfs_fh *fhandle,
  10502. +             struct nfs_fattr *fattr)
  10503. +{
  10504. +    int *p, *p0;
  10505. +    int status;
  10506. +    int ruid = 0;
  10507. +
  10508. +    PRINTK("NFS call  getattr\n");
  10509. +    if (!(p0 = nfs_rpc_alloc()))
  10510. +        return -EIO;
  10511. +retry:
  10512. +    p = nfs_rpc_header(p0, NFSPROC_GETATTR, ruid);
  10513. +    p = xdr_encode_fhandle(p, fhandle);
  10514. +    if ((status = nfs_rpc_call(server, p0, p)) < 0) {
  10515. +        nfs_rpc_free(p0);
  10516. +        return status;
  10517. +    }
  10518. +    if (!(p = nfs_rpc_verify(p0)))
  10519. +        status = NFSERR_IO;
  10520. +    else if ((status = ntohl(*p++)) == NFS_OK) {
  10521. +        p = xdr_decode_fattr(p, fattr);
  10522. +        PRINTK("NFS reply getattr\n");
  10523. +    }
  10524. +    else {
  10525. +        if (!ruid && current->euid == 0 && current->uid != 0) {
  10526. +            ruid = 1;
  10527. +            goto retry;
  10528. +        }
  10529. +        PRINTK("NFS reply getattr failed = %d\n", status);
  10530. +    }
  10531. +    nfs_rpc_free(p0);
  10532. +    return -nfs_stat_to_errno(status);
  10533. +}
  10534. +
  10535. +int nfs_proc_setattr(struct nfs_server *server, struct nfs_fh *fhandle,
  10536. +             struct nfs_sattr *sattr, struct nfs_fattr *fattr)
  10537. +{
  10538. +    int *p, *p0;
  10539. +    int status;
  10540. +    int ruid = 0;
  10541. +
  10542. +    PRINTK("NFS call  setattr\n");
  10543. +    if (!(p0 = nfs_rpc_alloc()))
  10544. +        return -EIO;
  10545. +retry:
  10546. +    p = nfs_rpc_header(p0, NFSPROC_SETATTR, ruid);
  10547. +    p = xdr_encode_fhandle(p, fhandle);
  10548. +    p = xdr_encode_sattr(p, sattr);
  10549. +    if ((status = nfs_rpc_call(server, p0, p)) < 0) {
  10550. +        nfs_rpc_free(p0);
  10551. +        return status;
  10552. +    }
  10553. +    if (!(p = nfs_rpc_verify(p0)))
  10554. +        status = NFSERR_IO;
  10555. +    else if ((status = ntohl(*p++)) == NFS_OK) {
  10556. +        p = xdr_decode_fattr(p, fattr);
  10557. +        PRINTK("NFS reply setattr\n");
  10558. +    }
  10559. +    else {
  10560. +        if (!ruid && current->euid == 0 && current->uid != 0) {
  10561. +            ruid = 1;
  10562. +            goto retry;
  10563. +        }
  10564. +        PRINTK("NFS reply setattr failed = %d\n", status);
  10565. +    }
  10566. +    nfs_rpc_free(p0);
  10567. +    return -nfs_stat_to_errno(status);
  10568. +}
  10569. +
  10570. +int nfs_proc_lookup(struct nfs_server *server, struct nfs_fh *dir, const char *name,
  10571. +            struct nfs_fh *fhandle, struct nfs_fattr *fattr)
  10572. +{
  10573. +    int *p, *p0;
  10574. +    int status;
  10575. +    int ruid = 0;
  10576. +
  10577. +    PRINTK("NFS call  lookup %s\n", name);
  10578. +#ifdef NFS_PROC_DEBUG
  10579. +    if (!strcmp(name, "xyzzy"))
  10580. +        proc_debug = 1 - proc_debug;
  10581. +#endif
  10582. +    if (!(p0 = nfs_rpc_alloc()))
  10583. +        return -EIO;
  10584. +retry:
  10585. +    p = nfs_rpc_header(p0, NFSPROC_LOOKUP, ruid);
  10586. +    p = xdr_encode_fhandle(p, dir);
  10587. +    p = xdr_encode_string(p, name);
  10588. +    if ((status = nfs_rpc_call(server, p0, p)) < 0) {
  10589. +        nfs_rpc_free(p0);
  10590. +        return status;
  10591. +    }
  10592. +    if (!(p = nfs_rpc_verify(p0)))
  10593. +        status = NFSERR_IO;
  10594. +    else if ((status = ntohl(*p++)) == NFS_OK) {
  10595. +        p = xdr_decode_fhandle(p, fhandle);
  10596. +        p = xdr_decode_fattr(p, fattr);
  10597. +        PRINTK("NFS reply lookup\n");
  10598. +    }
  10599. +    else {
  10600. +        if (!ruid && current->euid == 0 && current->uid != 0) {
  10601. +            ruid = 1;
  10602. +            goto retry;
  10603. +        }
  10604. +        PRINTK("NFS reply lookup failed = %d\n", status);
  10605. +    }
  10606. +    nfs_rpc_free(p0);
  10607. +    return -nfs_stat_to_errno(status);
  10608. +}
  10609. +
  10610. +int nfs_proc_readlink(struct nfs_server *server, struct nfs_fh *fhandle,
  10611. +              char *res)
  10612. +{
  10613. +    int *p, *p0;
  10614. +    int status;
  10615. +    int ruid = 0;
  10616. +
  10617. +    PRINTK("NFS call  readlink\n");
  10618. +    if (!(p0 = nfs_rpc_alloc()))
  10619. +        return -EIO;
  10620. +retry:
  10621. +    p = nfs_rpc_header(p0, NFSPROC_READLINK, ruid);
  10622. +    p = xdr_encode_fhandle(p, fhandle);
  10623. +    if ((status = nfs_rpc_call(server, p0, p)) < 0) {
  10624. +        nfs_rpc_free(p0);
  10625. +        return status;
  10626. +    }
  10627. +    if (!(p = nfs_rpc_verify(p0)))
  10628. +        status = NFSERR_IO;
  10629. +    else if ((status = ntohl(*p++)) == NFS_OK) {
  10630. +        if (!(p = xdr_decode_string(p, res, NFS_MAXPATHLEN))) {
  10631. +            printk("nfs_proc_readlink: giant pathname\n");
  10632. +            status = NFSERR_IO;
  10633. +        }
  10634. +        else
  10635. +            PRINTK("NFS reply readlink %s\n", res);
  10636. +    }
  10637. +    else {
  10638. +        if (!ruid && current->euid == 0 && current->uid != 0) {
  10639. +            ruid = 1;
  10640. +            goto retry;
  10641. +        }
  10642. +        PRINTK("NFS reply readlink failed = %d\n", status);
  10643. +    }
  10644. +    nfs_rpc_free(p0);
  10645. +    return -nfs_stat_to_errno(status);
  10646. +}
  10647. +
  10648. +int nfs_proc_read(struct nfs_server *server, struct nfs_fh *fhandle,
  10649. +          int offset, int count, char *data, struct nfs_fattr *fattr)
  10650. +{
  10651. +    int *p, *p0;
  10652. +    int status;
  10653. +    int ruid = 0;
  10654. +    int len = 0; /* = 0 is for gcc */
  10655. +
  10656. +    PRINTK("NFS call  read %d @ %d\n", count, offset);
  10657. +    if (!(p0 = nfs_rpc_alloc()))
  10658. +        return -EIO;
  10659. +retry:
  10660. +    p = nfs_rpc_header(p0, NFSPROC_READ, ruid);
  10661. +    p = xdr_encode_fhandle(p, fhandle);
  10662. +    *p++ = htonl(offset);
  10663. +    *p++ = htonl(count);
  10664. +    *p++ = htonl(count); /* traditional, could be any value */
  10665. +    if ((status = nfs_rpc_call(server, p0, p)) < 0) {
  10666. +        nfs_rpc_free(p0);
  10667. +        return status;
  10668. +    }
  10669. +    if (!(p = nfs_rpc_verify(p0)))
  10670. +        status = NFSERR_IO;
  10671. +    else if ((status = ntohl(*p++)) == NFS_OK) {
  10672. +        p = xdr_decode_fattr(p, fattr);
  10673. +        if (!(p = xdr_decode_data(p, data, &len, count))) {
  10674. +            printk("nfs_proc_read: giant data size\n"); 
  10675. +            status = NFSERR_IO;
  10676. +        }
  10677. +        else
  10678. +            PRINTK("NFS reply read %d\n", len);
  10679. +    }
  10680. +    else {
  10681. +        if (!ruid && current->euid == 0 && current->uid != 0) {
  10682. +            ruid = 1;
  10683. +            goto retry;
  10684. +        }
  10685. +        PRINTK("NFS reply read failed = %d\n", status);
  10686. +    }
  10687. +    nfs_rpc_free(p0);
  10688. +    return (status == NFS_OK) ? len : -nfs_stat_to_errno(status);
  10689. +}
  10690. +
  10691. +int nfs_proc_write(struct nfs_server *server, struct nfs_fh *fhandle,
  10692. +           int offset, int count, char *data, struct nfs_fattr *fattr)
  10693. +{
  10694. +    int *p, *p0;
  10695. +    int status;
  10696. +    int ruid = 0;
  10697. +
  10698. +    PRINTK("NFS call  write %d @ %d\n", count, offset);
  10699. +    if (!(p0 = nfs_rpc_alloc()))
  10700. +        return -EIO;
  10701. +retry:
  10702. +    p = nfs_rpc_header(p0, NFSPROC_WRITE, ruid);
  10703. +    p = xdr_encode_fhandle(p, fhandle);
  10704. +    *p++ = htonl(offset); /* traditional, could be any value */
  10705. +    *p++ = htonl(offset);
  10706. +    *p++ = htonl(count); /* traditional, could be any value */
  10707. +    p = xdr_encode_data(p, data, count);
  10708. +    if ((status = nfs_rpc_call(server, p0, p)) < 0) {
  10709. +        nfs_rpc_free(p0);
  10710. +        return status;
  10711. +    }
  10712. +    if (!(p = nfs_rpc_verify(p0)))
  10713. +        status = NFSERR_IO;
  10714. +    else if ((status = ntohl(*p++)) == NFS_OK) {
  10715. +        p = xdr_decode_fattr(p, fattr);
  10716. +        PRINTK("NFS reply write\n");
  10717. +    }
  10718. +    else {
  10719. +        if (!ruid && current->euid == 0 && current->uid != 0) {
  10720. +            ruid = 1;
  10721. +            goto retry;
  10722. +        }
  10723. +        PRINTK("NFS reply write failed = %d\n", status);
  10724. +    }
  10725. +    nfs_rpc_free(p0);
  10726. +    return -nfs_stat_to_errno(status);
  10727. +}
  10728. +
  10729. +int nfs_proc_create(struct nfs_server *server, struct nfs_fh *dir,
  10730. +            const char *name, struct nfs_sattr *sattr,
  10731. +            struct nfs_fh *fhandle, struct nfs_fattr *fattr)
  10732. +{
  10733. +    int *p, *p0;
  10734. +    int status;
  10735. +    int ruid = 0;
  10736. +
  10737. +    PRINTK("NFS call  create %s\n", name);
  10738. +    if (!(p0 = nfs_rpc_alloc()))
  10739. +        return -EIO;
  10740. +retry:
  10741. +    p = nfs_rpc_header(p0, NFSPROC_CREATE, ruid);
  10742. +    p = xdr_encode_fhandle(p, dir);
  10743. +    p = xdr_encode_string(p, name);
  10744. +    p = xdr_encode_sattr(p, sattr);
  10745. +    if ((status = nfs_rpc_call(server, p0, p)) < 0) {
  10746. +        nfs_rpc_free(p0);
  10747. +        return status;
  10748. +    }
  10749. +    if (!(p = nfs_rpc_verify(p0)))
  10750. +        status = NFSERR_IO;
  10751. +    else if ((status = ntohl(*p++)) == NFS_OK) {
  10752. +        p = xdr_decode_fhandle(p, fhandle);
  10753. +        p = xdr_decode_fattr(p, fattr);
  10754. +        PRINTK("NFS reply create\n");
  10755. +    }
  10756. +    else {
  10757. +        if (!ruid && current->euid == 0 && current->uid != 0) {
  10758. +            ruid = 1;
  10759. +            goto retry;
  10760. +        }
  10761. +        PRINTK("NFS reply create failed = %d\n", status);
  10762. +    }
  10763. +    nfs_rpc_free(p0);
  10764. +    return -nfs_stat_to_errno(status);
  10765. +}
  10766. +
  10767. +int nfs_proc_remove(struct nfs_server *server, struct nfs_fh *dir, const char *name)
  10768. +{
  10769. +    int *p, *p0;
  10770. +    int status;
  10771. +    int ruid = 0;
  10772. +
  10773. +    PRINTK("NFS call  remove %s\n", name);
  10774. +    if (!(p0 = nfs_rpc_alloc()))
  10775. +        return -EIO;
  10776. +retry:
  10777. +    p = nfs_rpc_header(p0, NFSPROC_REMOVE, ruid);
  10778. +    p = xdr_encode_fhandle(p, dir);
  10779. +    p = xdr_encode_string(p, name);
  10780. +    if ((status = nfs_rpc_call(server, p0, p)) < 0) {
  10781. +        nfs_rpc_free(p0);
  10782. +        return status;
  10783. +    }
  10784. +    if (!(p = nfs_rpc_verify(p0)))
  10785. +        status = NFSERR_IO;
  10786. +    else if ((status = ntohl(*p++)) == NFS_OK) {
  10787. +        PRINTK("NFS reply remove\n");
  10788. +    }
  10789. +    else {
  10790. +        if (!ruid && current->euid == 0 && current->uid != 0) {
  10791. +            ruid = 1;
  10792. +            goto retry;
  10793. +        }
  10794. +        PRINTK("NFS reply remove failed = %d\n", status);
  10795. +    }
  10796. +    nfs_rpc_free(p0);
  10797. +    return -nfs_stat_to_errno(status);
  10798. +}
  10799. +
  10800. +int nfs_proc_rename(struct nfs_server *server,
  10801. +            struct nfs_fh *old_dir, const char *old_name,
  10802. +            struct nfs_fh *new_dir, const char *new_name)
  10803. +{
  10804. +    int *p, *p0;
  10805. +    int status;
  10806. +    int ruid = 0;
  10807. +
  10808. +    PRINTK("NFS call  rename %s -> %s\n", old_name, new_name);
  10809. +    if (!(p0 = nfs_rpc_alloc()))
  10810. +        return -EIO;
  10811. +retry:
  10812. +    p = nfs_rpc_header(p0, NFSPROC_RENAME, ruid);
  10813. +    p = xdr_encode_fhandle(p, old_dir);
  10814. +    p = xdr_encode_string(p, old_name);
  10815. +    p = xdr_encode_fhandle(p, new_dir);
  10816. +    p = xdr_encode_string(p, new_name);
  10817. +    if ((status = nfs_rpc_call(server, p0, p)) < 0) {
  10818. +        nfs_rpc_free(p0);
  10819. +        return status;
  10820. +    }
  10821. +    if (!(p = nfs_rpc_verify(p0)))
  10822. +        status = NFSERR_IO;
  10823. +    else if ((status = ntohl(*p++)) == NFS_OK) {
  10824. +        PRINTK("NFS reply rename\n");
  10825. +    }
  10826. +    else {
  10827. +        if (!ruid && current->euid == 0 && current->uid != 0) {
  10828. +            ruid = 1;
  10829. +            goto retry;
  10830. +        }
  10831. +        PRINTK("NFS reply rename failed = %d\n", status);
  10832. +    }
  10833. +    nfs_rpc_free(p0);
  10834. +    return -nfs_stat_to_errno(status);
  10835. +}
  10836. +
  10837. +int nfs_proc_link(struct nfs_server *server, struct nfs_fh *fhandle,
  10838. +          struct nfs_fh *dir, const char *name)
  10839. +{
  10840. +    int *p, *p0;
  10841. +    int status;
  10842. +    int ruid = 0;
  10843. +
  10844. +    PRINTK("NFS call  link %s\n", name);
  10845. +    if (!(p0 = nfs_rpc_alloc()))
  10846. +        return -EIO;
  10847. +retry:
  10848. +    p = nfs_rpc_header(p0, NFSPROC_LINK, ruid);
  10849. +    p = xdr_encode_fhandle(p, fhandle);
  10850. +    p = xdr_encode_fhandle(p, dir);
  10851. +    p = xdr_encode_string(p, name);
  10852. +    if ((status = nfs_rpc_call(server, p0, p)) < 0) {
  10853. +        nfs_rpc_free(p0);
  10854. +        return status;
  10855. +    }
  10856. +    if (!(p = nfs_rpc_verify(p0)))
  10857. +        status = NFSERR_IO;
  10858. +    else if ((status = ntohl(*p++)) == NFS_OK) {
  10859. +        PRINTK("NFS reply link\n");
  10860. +    }
  10861. +    else {
  10862. +        if (!ruid && current->euid == 0 && current->uid != 0) {
  10863. +            ruid = 1;
  10864. +            goto retry;
  10865. +        }
  10866. +        PRINTK("NFS reply link failed = %d\n", status);
  10867. +    }
  10868. +    nfs_rpc_free(p0);
  10869. +    return -nfs_stat_to_errno(status);
  10870. +}
  10871. +
  10872. +int nfs_proc_symlink(struct nfs_server *server, struct nfs_fh *dir,
  10873. +             const char *name, const char *path, struct nfs_sattr *sattr)
  10874. +{
  10875. +    int *p, *p0;
  10876. +    int status;
  10877. +    int ruid = 0;
  10878. +
  10879. +    PRINTK("NFS call  symlink %s -> %s\n", name, path);
  10880. +    if (!(p0 = nfs_rpc_alloc()))
  10881. +        return -EIO;
  10882. +retry:
  10883. +    p = nfs_rpc_header(p0, NFSPROC_SYMLINK, ruid);
  10884. +    p = xdr_encode_fhandle(p, dir);
  10885. +    p = xdr_encode_string(p, name);
  10886. +    p = xdr_encode_string(p, path);
  10887. +    p = xdr_encode_sattr(p, sattr);
  10888. +    if ((status = nfs_rpc_call(server, p0, p)) < 0) {
  10889. +        nfs_rpc_free(p0);
  10890. +        return status;
  10891. +    }
  10892. +    if (!(p = nfs_rpc_verify(p0)))
  10893. +        status = NFSERR_IO;
  10894. +    else if ((status = ntohl(*p++)) == NFS_OK) {
  10895. +        PRINTK("NFS reply symlink\n");
  10896. +    }
  10897. +    else {
  10898. +        if (!ruid && current->euid == 0 && current->uid != 0) {
  10899. +            ruid = 1;
  10900. +            goto retry;
  10901. +        }
  10902. +        PRINTK("NFS reply symlink failed = %d\n", status);
  10903. +    }
  10904. +    nfs_rpc_free(p0);
  10905. +    return -nfs_stat_to_errno(status);
  10906. +}
  10907. +
  10908. +int nfs_proc_mkdir(struct nfs_server *server, struct nfs_fh *dir,
  10909. +           const char *name, struct nfs_sattr *sattr,
  10910. +           struct nfs_fh *fhandle, struct nfs_fattr *fattr)
  10911. +{
  10912. +    int *p, *p0;
  10913. +    int status;
  10914. +    int ruid = 0;
  10915. +
  10916. +    PRINTK("NFS call  mkdir %s\n", name);
  10917. +    if (!(p0 = nfs_rpc_alloc()))
  10918. +        return -EIO;
  10919. +retry:
  10920. +    p = nfs_rpc_header(p0, NFSPROC_MKDIR, ruid);
  10921. +    p = xdr_encode_fhandle(p, dir);
  10922. +    p = xdr_encode_string(p, name);
  10923. +    p = xdr_encode_sattr(p, sattr);
  10924. +    if ((status = nfs_rpc_call(server, p0, p)) < 0) {
  10925. +        nfs_rpc_free(p0);
  10926. +        return status;
  10927. +    }
  10928. +    if (!(p = nfs_rpc_verify(p0)))
  10929. +        status = NFSERR_IO;
  10930. +    else if ((status = ntohl(*p++)) == NFS_OK) {
  10931. +        p = xdr_decode_fhandle(p, fhandle);
  10932. +        p = xdr_decode_fattr(p, fattr);
  10933. +        PRINTK("NFS reply mkdir\n");
  10934. +    }
  10935. +    else {
  10936. +        if (!ruid && current->euid == 0 && current->uid != 0) {
  10937. +            ruid = 1;
  10938. +            goto retry;
  10939. +        }
  10940. +        PRINTK("NFS reply mkdir failed = %d\n", status);
  10941. +    }
  10942. +    nfs_rpc_free(p0);
  10943. +    return -nfs_stat_to_errno(status);
  10944. +}
  10945. +
  10946. +int nfs_proc_rmdir(struct nfs_server *server, struct nfs_fh *dir, const char *name)
  10947. +{
  10948. +    int *p, *p0;
  10949. +    int status;
  10950. +    int ruid = 0;
  10951. +
  10952. +    PRINTK("NFS call  rmdir %s\n", name);
  10953. +    if (!(p0 = nfs_rpc_alloc()))
  10954. +        return -EIO;
  10955. +retry:
  10956. +    p = nfs_rpc_header(p0, NFSPROC_RMDIR, ruid);
  10957. +    p = xdr_encode_fhandle(p, dir);
  10958. +    p = xdr_encode_string(p, name);
  10959. +    if ((status = nfs_rpc_call(server, p0, p)) < 0) {
  10960. +        nfs_rpc_free(p0);
  10961. +        return status;
  10962. +    }
  10963. +    if (!(p = nfs_rpc_verify(p0)))
  10964. +        status = NFSERR_IO;
  10965. +    else if ((status = ntohl(*p++)) == NFS_OK) {
  10966. +        PRINTK("NFS reply rmdir\n");
  10967. +    }
  10968. +    else {
  10969. +        if (!ruid && current->euid == 0 && current->uid != 0) {
  10970. +            ruid = 1;
  10971. +            goto retry;
  10972. +        }
  10973. +        PRINTK("NFS reply rmdir failed = %d\n", status);
  10974. +    }
  10975. +    nfs_rpc_free(p0);
  10976. +    return -nfs_stat_to_errno(status);
  10977. +}
  10978. +
  10979. +int nfs_proc_readdir(struct nfs_server *server, struct nfs_fh *fhandle,
  10980. +             int cookie, int count, struct nfs_entry *entry)
  10981. +{
  10982. +    int *p, *p0;
  10983. +    int status;
  10984. +    int ruid = 0;
  10985. +    int i = 0; /* = 0 is for gcc */
  10986. +    int size;
  10987. +    int eof;
  10988. +
  10989. +    PRINTK("NFS call  readdir %d @ %d\n", count, cookie);
  10990. +    size = server->rsize;
  10991. +    if (!(p0 = nfs_rpc_alloc()))
  10992. +        return -EIO;
  10993. +retry:
  10994. +    p = nfs_rpc_header(p0, NFSPROC_READDIR, ruid);
  10995. +    p = xdr_encode_fhandle(p, fhandle);
  10996. +    *p++ = htonl(cookie);
  10997. +    *p++ = htonl(size);
  10998. +    if ((status = nfs_rpc_call(server, p0, p)) < 0) {
  10999. +        nfs_rpc_free(p0);
  11000. +        return status;
  11001. +    }
  11002. +    if (!(p = nfs_rpc_verify(p0)))
  11003. +        status = NFSERR_IO;
  11004. +    else if ((status = ntohl(*p++)) == NFS_OK) {
  11005. +        for (i = 0; i < count && *p++; i++) {
  11006. +            if (!(p = xdr_decode_entry(p, entry++)))
  11007. +                break;
  11008. +        }
  11009. +        if (!p) {
  11010. +            printk("nfs_proc_readdir: giant filename\n");
  11011. +            status = NFSERR_IO;
  11012. +        }
  11013. +        else {
  11014. +            eof = (i == count && !*p++ && *p++)
  11015. +                  || (i < count && *p++);
  11016. +            if (eof && i)
  11017. +                entry[-1].eof = 1;
  11018. +            PRINTK("NFS reply readdir %d %s\n", i,
  11019. +                   eof ? "eof" : "");
  11020. +        }
  11021. +    }
  11022. +    else {
  11023. +        if (!ruid && current->euid == 0 && current->uid != 0) {
  11024. +            ruid = 1;
  11025. +            goto retry;
  11026. +        }
  11027. +        PRINTK("NFS reply readdir failed = %d\n", status);
  11028. +    }
  11029. +    nfs_rpc_free(p0);
  11030. +    return (status == NFS_OK) ? i : -nfs_stat_to_errno(status);
  11031. +}
  11032. +
  11033. +int nfs_proc_statfs(struct nfs_server *server, struct nfs_fh *fhandle,
  11034. +            struct nfs_fsinfo *res)
  11035. +{
  11036. +    int *p, *p0;
  11037. +    int status;
  11038. +    int ruid = 0;
  11039. +
  11040. +    PRINTK("NFS call  statfs\n");
  11041. +    if (!(p0 = nfs_rpc_alloc()))
  11042. +        return -EIO;
  11043. +retry:
  11044. +    p = nfs_rpc_header(p0, NFSPROC_STATFS, ruid);
  11045. +    p = xdr_encode_fhandle(p, fhandle);
  11046. +    if ((status = nfs_rpc_call(server, p0, p)) < 0) {
  11047. +        nfs_rpc_free(p0);
  11048. +        return status;
  11049. +    }
  11050. +    if (!(p = nfs_rpc_verify(p0)))
  11051. +        status = NFSERR_IO;
  11052. +    else if ((status = ntohl(*p++)) == NFS_OK) {
  11053. +        p = xdr_decode_fsinfo(p, res);
  11054. +        PRINTK("NFS reply statfs\n");
  11055. +    }
  11056. +    else {
  11057. +        if (!ruid && current->euid == 0 && current->uid != 0) {
  11058. +            ruid = 1;
  11059. +            goto retry;
  11060. +        }
  11061. +        PRINTK("NFS reply statfs failed = %d\n", status);
  11062. +    }
  11063. +    nfs_rpc_free(p0);
  11064. +    return -nfs_stat_to_errno(status);
  11065. +}
  11066. +
  11067. +/*
  11068. + * Here are a few RPC-assist functions.
  11069. + */
  11070. +
  11071. +static int *nfs_rpc_header(int *p, int procedure, int ruid)
  11072. +{
  11073. +    int *p1, *p2;
  11074. +    int i;
  11075. +    static int xid = 0;
  11076. +    unsigned char *sys = (unsigned char *) system_utsname.nodename;
  11077. +
  11078. +    if (xid == 0) {
  11079. +        xid = CURRENT_TIME;
  11080. +        xid ^= (sys[3]<<24) | (sys[2]<<16) | (sys[1]<<8) | sys[0];
  11081. +    }
  11082. +    *p++ = htonl(++xid);
  11083. +    *p++ = htonl(RPC_CALL);
  11084. +    *p++ = htonl(RPC_VERSION);
  11085. +    *p++ = htonl(NFS_PROGRAM);
  11086. +    *p++ = htonl(NFS_VERSION);
  11087. +    *p++ = htonl(procedure);
  11088. +    *p++ = htonl(RPC_AUTH_UNIX);
  11089. +    p1 = p++;
  11090. +    *p++ = htonl(CURRENT_TIME); /* traditional, could be anything */
  11091. +    p = xdr_encode_string(p, (char *) sys);
  11092. +    *p++ = htonl(ruid ? current->uid : current->euid);
  11093. +    *p++ = htonl(current->egid);
  11094. +    p2 = p++;
  11095. +    for (i = 0; i < 16 && i < NGROUPS && current->groups[i] != NOGROUP; i++)
  11096. +        *p++ = htonl(current->groups[i]);
  11097. +    *p2 = htonl(i);
  11098. +    *p1 = htonl((p - (p1 + 1)) << 2);
  11099. +    *p++ = htonl(RPC_AUTH_NULL);
  11100. +    *p++ = htonl(0);
  11101. +    return p;
  11102. +}
  11103. +
  11104. +static int *nfs_rpc_verify(int *p)
  11105. +{
  11106. +    unsigned int n;
  11107. +
  11108. +    p++;
  11109. +    if ((n = ntohl(*p++)) != RPC_REPLY) {
  11110. +        printk("nfs_rpc_verify: not an RPC reply: %d\n", n);
  11111. +        return NULL;
  11112. +    }
  11113. +    if ((n = ntohl(*p++)) != RPC_MSG_ACCEPTED) {
  11114. +        printk("nfs_rpc_verify: RPC call rejected: %d\n", n);
  11115. +        return NULL;
  11116. +    }
  11117. +    switch (n = ntohl(*p++)) {
  11118. +    case RPC_AUTH_NULL: case RPC_AUTH_UNIX: case RPC_AUTH_SHORT:
  11119. +        break;
  11120. +    default:
  11121. +        printk("nfs_rpc_verify: bad RPC authentication type: %d\n", n);
  11122. +        return NULL;
  11123. +    }
  11124. +    if ((n = ntohl(*p++)) > 400) {
  11125. +        printk("nfs_rpc_verify: giant auth size\n");
  11126. +        return NULL;
  11127. +    }
  11128. +    p += (n + 3) >> 2;
  11129. +    if ((n = ntohl(*p++)) != RPC_SUCCESS) {
  11130. +        printk("nfs_rpc_verify: RPC call failed: %d\n", n);
  11131. +        return NULL;
  11132. +    }
  11133. +    return p;
  11134. +}
  11135. +    
  11136. +/*
  11137. + * We need to translate between nfs status return values and
  11138. + * the local errno values which may not be the same.
  11139. + */
  11140. +
  11141. +#ifndef EDQUOT
  11142. +#define EDQUOT    ENOSPC
  11143. +#endif
  11144. +
  11145. +static struct {
  11146. +    int stat;
  11147. +    int errno;
  11148. +} nfs_errtbl[] = {
  11149. +    { NFS_OK,        0        },
  11150. +    { NFSERR_PERM,        EPERM        },
  11151. +    { NFSERR_NOENT,        ENOENT        },
  11152. +    { NFSERR_IO,        EIO        },
  11153. +    { NFSERR_NXIO,        ENXIO        },
  11154. +    { NFSERR_ACCES,        EACCES        },
  11155. +    { NFSERR_EXIST,        EEXIST        },
  11156. +    { NFSERR_NODEV,        ENODEV        },
  11157. +    { NFSERR_NOTDIR,    ENOTDIR        },
  11158. +    { NFSERR_ISDIR,        EISDIR        },
  11159. +    { NFSERR_INVAL,        EINVAL        },
  11160. +    { NFSERR_FBIG,        EFBIG        },
  11161. +    { NFSERR_NOSPC,        ENOSPC        },
  11162. +    { NFSERR_ROFS,        EROFS        },
  11163. +    { NFSERR_NAMETOOLONG,    ENAMETOOLONG    },
  11164. +    { NFSERR_NOTEMPTY,    ENOTEMPTY    },
  11165. +    { NFSERR_DQUOT,        EDQUOT        },
  11166. +    { NFSERR_STALE,        ESTALE        },
  11167. +#ifdef EWFLUSH
  11168. +    { NFSERR_WFLUSH,    EWFLUSH        },
  11169. +#endif
  11170. +    { -1,            EIO        }
  11171. +};
  11172. +
  11173. +static int nfs_stat_to_errno(int stat)
  11174. +{
  11175. +    int i;
  11176. +
  11177. +    for (i = 0; nfs_errtbl[i].stat != -1; i++) {
  11178. +        if (nfs_errtbl[i].stat == stat)
  11179. +            return nfs_errtbl[i].errno;
  11180. +    }
  11181. +    printk("nfs_stat_to_errno: bad nfs status return value: %d\n", stat);
  11182. +    return nfs_errtbl[i].errno;
  11183. +}
  11184. +
  11185. diff -ubr -x RCS -x *.[ao] -x .depend -x .version -x .config -x System.map -x vmlinux -x bootstrap -x *~ -x config.old -x *.orig -x *.rej -x *# -x version.h -x autoconf.h --new-file linux-0.9pl3/fs/nfs/sock.c linux-0.9pl4/fs/nfs/sock.c
  11186. --- linux-0.9pl3/fs/nfs/sock.c    Wed Dec 31 19:00:00 1969
  11187. +++ linux-0.9pl4/fs/nfs/sock.c    Tue Mar  1 01:03:41 1994
  11188. @@ -0,0 +1,185 @@
  11189. +/*
  11190. + *  linux/fs/nfs/sock.c
  11191. + *
  11192. + *  Copyright (C) 1992, 1993  Rick Sladkey
  11193. + *
  11194. + *  low-level nfs remote procedure call interface
  11195. + */
  11196. +
  11197. +#include <linux/config.h>
  11198. +#include <linux/sched.h>
  11199. +#include <linux/nfs_fs.h>
  11200. +#include <linux/errno.h>
  11201. +#include <linux/socket.h>
  11202. +#include <linux/fcntl.h>
  11203. +#include <asm/segment.h>
  11204. +#include <linux/in.h>
  11205. +#include <linux/net.h>
  11206. +
  11207. +
  11208. +extern struct socket *socki_lookup(struct inode *inode);
  11209. +
  11210. +#define _S(nr) (1<<((nr)-1))
  11211. +
  11212. +/*
  11213. + * We violate some modularity principles here by poking around
  11214. + * in some socket internals.  Besides having to call socket
  11215. + * functions from kernel-space instead of user space, the socket
  11216. + * interface does not lend itself well to being cleanly called
  11217. + * without a file descriptor.  Since the nfs calls can run on
  11218. + * behalf of any process, the superblock maintains a file pointer
  11219. + * to the server socket.
  11220. + */
  11221. +
  11222. +static int do_nfs_rpc_call(struct nfs_server *server, int *start, int *end)
  11223. +{
  11224. +    struct file *file;
  11225. +    struct inode *inode;
  11226. +    struct socket *sock;
  11227. +    unsigned short fs;
  11228. +    int result;
  11229. +    int xid;
  11230. +    int len;
  11231. +    select_table wait_table;
  11232. +    struct select_table_entry entry;
  11233. +    int (*select) (struct inode *, struct file *, int, select_table *);
  11234. +    int init_timeout, max_timeout;
  11235. +    int timeout;
  11236. +    int retrans;
  11237. +    int major_timeout_seen;
  11238. +    char *server_name;
  11239. +    int n;
  11240. +    int addrlen;
  11241. +    unsigned long old_mask;
  11242. +
  11243. +    xid = start[0];
  11244. +    len = ((char *) end) - ((char *) start);
  11245. +    file = server->file;
  11246. +    inode = file->f_inode;
  11247. +    select = file->f_op->select;
  11248. +    sock = socki_lookup(inode);
  11249. +    if (!sock) {
  11250. +        printk("nfs_rpc_call: socki_lookup failed\n");
  11251. +        return -EBADF;
  11252. +    }
  11253. +    init_timeout = server->timeo;
  11254. +    max_timeout = NFS_MAX_RPC_TIMEOUT*HZ/10;
  11255. +    retrans = server->retrans;
  11256. +    major_timeout_seen = 0;
  11257. +    server_name = server->hostname;
  11258. +    old_mask = current->blocked;
  11259. +    current->blocked |= ~(_S(SIGKILL)
  11260. +#if 0
  11261. +        | _S(SIGSTOP)
  11262. +#endif
  11263. +        | ((server->flags & NFS_MOUNT_INTR)
  11264. +        ? ((current->sigaction[SIGINT - 1].sa_handler == SIG_DFL
  11265. +            ? _S(SIGINT) : 0)
  11266. +        | (current->sigaction[SIGQUIT - 1].sa_handler == SIG_DFL
  11267. +            ? _S(SIGQUIT) : 0))
  11268. +        : 0));
  11269. +    fs = get_fs();
  11270. +    set_fs(get_ds());
  11271. +    for (n = 0, timeout = init_timeout; ; n++, timeout <<= 1) {
  11272. +        result = sock->ops->send(sock, (void *) start, len, 0, 0);
  11273. +        if (result < 0) {
  11274. +            printk("nfs_rpc_call: send error = %d\n", result);
  11275. +            break;
  11276. +        }
  11277. +    re_select:
  11278. +        wait_table.nr = 0;
  11279. +        wait_table.entry = &entry;
  11280. +        current->state = TASK_INTERRUPTIBLE;
  11281. +        if (!select(inode, file, SEL_IN, &wait_table)
  11282. +            && !select(inode, file, SEL_IN, NULL)) {
  11283. +            if (timeout > max_timeout)
  11284. +                timeout = max_timeout;
  11285. +            current->timeout = jiffies + timeout;
  11286. +            schedule();
  11287. +            remove_wait_queue(entry.wait_address, &entry.wait);
  11288. +            current->state = TASK_RUNNING;
  11289. +            if (current->signal & ~current->blocked) {
  11290. +                current->timeout = 0;
  11291. +                result = -ERESTARTSYS;
  11292. +                break;
  11293. +            }
  11294. +            if (!current->timeout) {
  11295. +                if (n < retrans)
  11296. +                    continue;
  11297. +                if (server->flags & NFS_MOUNT_SOFT) {
  11298. +                    printk("NFS server %s not responding, "
  11299. +                        "timed out\n", server_name);
  11300. +                    result = -EIO;
  11301. +                    break;
  11302. +                }
  11303. +                n = 0;
  11304. +                timeout = init_timeout;
  11305. +                init_timeout <<= 1;
  11306. +                if (!major_timeout_seen) {
  11307. +                    printk("NFS server %s not responding, "
  11308. +                        "still trying\n", server_name);
  11309. +                }
  11310. +                major_timeout_seen = 1;
  11311. +                continue;
  11312. +            }
  11313. +            else
  11314. +                current->timeout = 0;
  11315. +        }
  11316. +        else if (wait_table.nr)
  11317. +            remove_wait_queue(entry.wait_address, &entry.wait);
  11318. +        current->state = TASK_RUNNING;
  11319. +        addrlen = 0;
  11320. +        result = sock->ops->recvfrom(sock, (void *) start, PAGE_SIZE, 1, 0,
  11321. +            NULL, &addrlen);
  11322. +        if (result < 0) {
  11323. +            if (result == -EAGAIN) {
  11324. +#if 0
  11325. +                printk("nfs_rpc_call: bad select ready\n");
  11326. +#endif
  11327. +                goto re_select;
  11328. +            }
  11329. +            if (result == -ECONNREFUSED) {
  11330. +#if 0
  11331. +                printk("nfs_rpc_call: server playing coy\n");
  11332. +#endif
  11333. +                goto re_select;
  11334. +            }
  11335. +            if (result != -ERESTARTSYS) {
  11336. +                printk("nfs_rpc_call: recv error = %d\n",
  11337. +                    -result);
  11338. +            }
  11339. +            break;
  11340. +        }
  11341. +        if (*start == xid) {
  11342. +            if (major_timeout_seen)
  11343. +                printk("NFS server %s OK\n", server_name);
  11344. +            break;
  11345. +        }
  11346. +#if 0
  11347. +        printk("nfs_rpc_call: XID mismatch\n");
  11348. +#endif
  11349. +    }
  11350. +    current->blocked = old_mask;
  11351. +    set_fs(fs);
  11352. +    return result;
  11353. +}
  11354. +
  11355. +/*
  11356. + * For now we lock out other simulaneous nfs calls for the same filesytem
  11357. + * because we are single-threaded and don't want to get mismatched
  11358. + * RPC replies.
  11359. + */
  11360. +
  11361. +int nfs_rpc_call(struct nfs_server *server, int *start, int *end)
  11362. +{
  11363. +    int result;
  11364. +
  11365. +    while (server->lock)
  11366. +        sleep_on(&server->wait);
  11367. +    server->lock = 1;
  11368. +    result = do_nfs_rpc_call(server, start, end);
  11369. +    server->lock = 0;
  11370. +    wake_up(&server->wait);
  11371. +    return result;
  11372. +}
  11373. +
  11374. diff -ubr -x RCS -x *.[ao] -x .depend -x .version -x .config -x System.map -x vmlinux -x bootstrap -x *~ -x config.old -x *.orig -x *.rej -x *# -x version.h -x autoconf.h --new-file linux-0.9pl3/fs/nfs/symlink.c linux-0.9pl4/fs/nfs/symlink.c
  11375. --- linux-0.9pl3/fs/nfs/symlink.c    Wed Dec 31 19:00:00 1969
  11376. +++ linux-0.9pl4/fs/nfs/symlink.c    Wed Dec  1 07:44:15 1993
  11377. @@ -0,0 +1,108 @@
  11378. +/*
  11379. + *  linux/fs/nfs/symlink.c
  11380. + *
  11381. + *  Copyright (C) 1992  Rick Sladkey
  11382. + *
  11383. + *  nfs symlink handling code
  11384. + */
  11385. +
  11386. +#include <asm/segment.h>
  11387. +
  11388. +#include <linux/sched.h>
  11389. +#include <linux/errno.h>
  11390. +#include <linux/nfs_fs.h>
  11391. +#include <linux/stat.h>
  11392. +#include <linux/mm.h>
  11393. +#include <linux/malloc.h>
  11394. +
  11395. +static int nfs_readlink(struct inode *, char *, int);
  11396. +static int nfs_follow_link(struct inode *, struct inode *, int, int,
  11397. +               struct inode **);
  11398. +
  11399. +/*
  11400. + * symlinks can't do much...
  11401. + */
  11402. +struct inode_operations nfs_symlink_inode_operations = {
  11403. +    NULL,            /* no file-operations */
  11404. +    NULL,            /* create */
  11405. +    NULL,            /* lookup */
  11406. +    NULL,            /* link */
  11407. +    NULL,            /* unlink */
  11408. +    NULL,            /* symlink */
  11409. +    NULL,            /* mkdir */
  11410. +    NULL,            /* rmdir */
  11411. +    NULL,            /* mknod */
  11412. +    NULL,            /* rename */
  11413. +    nfs_readlink,        /* readlink */
  11414. +    nfs_follow_link,    /* follow_link */
  11415. +    NULL,            /* bmap */
  11416. +    NULL,            /* truncate */
  11417. +    NULL            /* permission */
  11418. +};
  11419. +
  11420. +static int nfs_follow_link(struct inode *dir, struct inode *inode,
  11421. +               int flag, int mode, struct inode **res_inode)
  11422. +{
  11423. +    int error;
  11424. +    char *res;
  11425. +
  11426. +    *res_inode = NULL;
  11427. +    if (!dir) {
  11428. +        dir = current->root;
  11429. +        dir->i_count++;
  11430. +    }
  11431. +    if (!inode) {
  11432. +        iput(dir);
  11433. +        return -ENOENT;
  11434. +    }
  11435. +    if (!S_ISLNK(inode->i_mode)) {
  11436. +        iput(dir);
  11437. +        *res_inode = inode;
  11438. +        return 0;
  11439. +    }
  11440. +    if (current->link_count > 5) {
  11441. +        iput(inode);
  11442. +        iput(dir);
  11443. +        return -ELOOP;
  11444. +    }
  11445. +    res = (char *) kmalloc(NFS_MAXPATHLEN + 1, GFP_KERNEL);
  11446. +    error = nfs_proc_readlink(NFS_SERVER(inode), NFS_FH(inode), res);
  11447. +    if (error) {
  11448. +        iput(inode);
  11449. +        iput(dir);
  11450. +        kfree_s(res, NFS_MAXPATHLEN + 1);
  11451. +        return error;
  11452. +    }
  11453. +    iput(inode);
  11454. +    current->link_count++;
  11455. +    error = open_namei(res, flag, mode, res_inode, dir);
  11456. +    current->link_count--;
  11457. +    kfree_s(res, NFS_MAXPATHLEN + 1);
  11458. +    return error;
  11459. +}
  11460. +
  11461. +static int nfs_readlink(struct inode *inode, char *buffer, int buflen)
  11462. +{
  11463. +    int i;
  11464. +    char c;
  11465. +    int error;
  11466. +    char *res;
  11467. +
  11468. +    if (!S_ISLNK(inode->i_mode)) {
  11469. +        iput(inode);
  11470. +        return -EINVAL;
  11471. +    }
  11472. +    if (buflen > NFS_MAXPATHLEN)
  11473. +        buflen = NFS_MAXPATHLEN;
  11474. +    res = (char *) kmalloc(buflen + 1, GFP_KERNEL);
  11475. +    error = nfs_proc_readlink(NFS_SERVER(inode), NFS_FH(inode), res);
  11476. +    iput(inode);
  11477. +    if (error) {
  11478. +        kfree_s(res, buflen + 1);
  11479. +        return error;
  11480. +    }
  11481. +    for (i = 0; i < buflen && (c = res[i]); i++)
  11482. +        put_fs_byte(c,buffer++);
  11483. +    kfree_s(res, buflen + 1);
  11484. +    return i;
  11485. +}
  11486. diff -ubr -x RCS -x *.[ao] -x .depend -x .version -x .config -x System.map -x vmlinux -x bootstrap -x *~ -x config.old -x *.orig -x *.rej -x *# -x version.h -x autoconf.h --new-file linux-0.9pl3/include/asm/segment.h linux-0.9pl4/include/asm/segment.h
  11487. --- linux-0.9pl3/include/asm/segment.h    Fri Aug 19 17:05:08 1994
  11488. +++ linux-0.9pl4/include/asm/segment.h    Mon Oct 10 16:48:26 1994
  11489. @@ -83,20 +83,19 @@
  11490.  
  11491.  static inline void __constant_memcpy_tofs(void * to, const void * from, unsigned long n)
  11492.  {
  11493. -    switch (n) {
  11494. -        case 0:
  11495. +    if (n == 0) {
  11496.              return;
  11497. -        case 1:
  11498. +    } else if (n == 1) {
  11499.              put_user_byte(*(const char *) from, (char *) to);
  11500.              return;
  11501. -        case 2:
  11502. +    } else if (n == 2) {
  11503.              put_user_word(*(const short *) from, (short *) to);
  11504.              return;
  11505. -        case 3:
  11506. +    } else if (n == 3) {
  11507.              put_user_word(*(const short *) from, (short *) to);
  11508.              put_user_byte(*(2+(const char *) from), 2+(char *) to);
  11509.              return;
  11510. -        case 4:
  11511. +    } else if (n == 4) {
  11512.              put_user_long(*(const int *) from, (int *) to);
  11513.              return;
  11514.      }
  11515. @@ -150,20 +149,19 @@
  11516.  
  11517.  static inline void __constant_memcpy_fromfs(void * to, const void * from, unsigned long n)
  11518.  {
  11519. -    switch (n) {
  11520. -        case 0:
  11521. +    if (n == 0) {
  11522.              return;
  11523. -        case 1:
  11524. +    } else if (n == 1) {
  11525.              *(char *)to = get_user_byte((const char *) from);
  11526.              return;
  11527. -        case 2:
  11528. +    } else if (n == 2) {
  11529.              *(short *)to = get_user_word((const short *) from);
  11530.              return;
  11531. -        case 3:
  11532. +    } else if (n == 3) {
  11533.              *(short *) to = get_user_word((const short *) from);
  11534.              *(2+(char *) to) = get_user_byte(2+(const char *) from);
  11535.              return;
  11536. -        case 4:
  11537. +    } else if (n == 4) {
  11538.              *(int *) to = get_user_long((const int *) from);
  11539.              return;
  11540.      }
  11541. diff -ubr -x RCS -x *.[ao] -x .depend -x .version -x .config -x System.map -x vmlinux -x bootstrap -x *~ -x config.old -x *.orig -x *.rej -x *# -x version.h -x autoconf.h --new-file linux-0.9pl3/include/linux/amihdreg.h linux-0.9pl4/include/linux/amihdreg.h
  11542. --- linux-0.9pl3/include/linux/amihdreg.h    Sun Aug 14 10:29:35 1994
  11543. +++ linux-0.9pl4/include/linux/amihdreg.h    Thu Nov 24 20:52:38 1994
  11544. @@ -10,20 +10,23 @@
  11545.  #define IDE_DISABLE_IRQ  0x02
  11546.  #define IDE_ENABLE_IRQ   0x00
  11547.   
  11548. -/* Hd controller regs. Ref: Disassembling scsi.device */
  11549. -#define HD_DATA        0xdd2020    /* _CTL when writing */
  11550. -#define HD_ERROR    0xdd2026    /* see err-bits */
  11551. -#define HD_NSECTOR    0xdd202a    /* nr of sectors to read/write */
  11552. -#define HD_SECTOR    0xdd202e    /* starting sector */
  11553. -#define HD_LCYL        0xdd2032    /* starting cylinder */
  11554. -#define HD_HCYL        0xdd2036    /* high byte of starting cyl */
  11555. -#define HD_CURRENT    0xdd203a    /* 101dhhhh , d=drive, hhhh=head */
  11556. -#define HD_STATUS    0xdd203e    /* see status-bits */
  11557. -#define HD_PRECOMP HD_ERROR    /* same io address, read=error, write=precomp */
  11558. -#define HD_COMMAND HD_STATUS    /* same io address, read=status, write=cmd */
  11559. +/* Bases of the hard drive controller */
  11560. +#define HD_BASE_A4000   0xdd2020
  11561. +#define HD_BASE_A1200   0xda0000
  11562.  
  11563. -#define HD_IRQ_TEST 0xdd3020  /* MSB = 1, Harddisk is source of interrupt */
  11564. -#define HD_CMD          0xdd303a
  11565. +/* Offsets from one of the above bases */
  11566. +#define HD_ERROR    (0x06)        /* see err-bits */
  11567. +#define HD_NSECTOR    (0x0a)        /* nr of sectors to read/write */
  11568. +#define HD_SECTOR    (0x0e)        /* starting sector */
  11569. +#define HD_LCYL        (0x12)        /* starting cylinder */
  11570. +#define HD_HCYL        (0x16)        /* high byte of starting cyl */
  11571. +#define HD_CURRENT    (0x1a)        /* 101dhhhh , d=drive, hhhh=head */
  11572. +#define HD_STATUS    (0x1e)        /* see status-bits */
  11573. +#define HD_CMD        (0x101a)
  11574. +
  11575. +/* These are at different offsets from the base */
  11576. +#define HD_A4000_IRQ    (0xdd3020)    /* MSB = 1, Harddisk is source of interrupt */
  11577. +#define HD_A1200_IRQ    (0xda9000)    /* MSB = 1, Harddisk is source of interrupt */
  11578.  
  11579.  /* Bits of HD_STATUS */
  11580.  #define ERR_STAT    0x01
  11581. diff -ubr -x RCS -x *.[ao] -x .depend -x .version -x .config -x System.map -x vmlinux -x bootstrap -x *~ -x config.old -x *.orig -x *.rej -x *# -x version.h -x autoconf.h --new-file linux-0.9pl3/include/linux/atafdreg.h linux-0.9pl4/include/linux/atafdreg.h
  11582. --- linux-0.9pl3/include/linux/atafdreg.h    Sun Aug 14 10:29:37 1994
  11583. +++ linux-0.9pl4/include/linux/atafdreg.h    Mon Nov  7 22:33:51 1994
  11584. @@ -5,10 +5,22 @@
  11585.  ** WD1772 stuff
  11586.   */
  11587.  
  11588. -#define FDCSELREG_STP   (0x80)
  11589. -#define FDCSELREG_TRA   (0x82)
  11590. -#define FDCSELREG_SEC   (0x84)
  11591. -#define FDCSELREG_DTA   (0x86)
  11592. +/* register codes */
  11593. +
  11594. +#define FDCSELREG_STP   (0x80)   /* command/status register */
  11595. +#define FDCSELREG_TRA   (0x82)   /* track register */
  11596. +#define FDCSELREG_SEC   (0x84)   /* sector register */
  11597. +#define FDCSELREG_DTA   (0x86)   /* data register */
  11598. +
  11599. +/* register names for FDC_READ/WRITE macros */
  11600. +
  11601. +#define FDCREG_CMD        0
  11602. +#define FDCREG_STATUS    0
  11603. +#define FDCREG_TRACK    2
  11604. +#define FDCREG_SECTOR    4
  11605. +#define FDCREG_DATA        6
  11606. +
  11607. +/* command opcodes */
  11608.  
  11609.  #define FDCCMD_RESTORE  (0x00)   /*  -                   */
  11610.  #define FDCCMD_SEEK     (0x10)   /*   |                  */
  11611. @@ -20,26 +32,35 @@
  11612.  #define FDCCMD_RDADR    (0xc0)   /*  -                   */
  11613.  #define FDCCMD_RDTRA    (0xe0)   /*   |  TYP 3 Commands  */
  11614.  #define FDCCMD_WRTRA    (0xf0)   /*  -                   */
  11615. -#define FDCCMD_FORCI    (0xc0)   /*  -   TYP 4 Command   */
  11616. +#define FDCCMD_FORCI    (0xd0)   /*  -   TYP 4 Command   */
  11617. +
  11618. +/* command modifier bits */
  11619.  
  11620. -#define FDCCMDADD_SR6   (0x00)
  11621. +#define FDCCMDADD_SR6   (0x00)   /* step rate settings */
  11622.  #define FDCCMDADD_SR12  (0x01)
  11623.  #define FDCCMDADD_SR2   (0x02)
  11624.  #define FDCCMDADD_SR3   (0x03)
  11625. -
  11626. -#define FDCCMDADD_V     (0x04)
  11627. -
  11628. -#define FDCCMDADD_H     (0x08)
  11629. -
  11630. -#define FDCCMDADD_U     (0x10)
  11631. -
  11632. -#define FDCCMDADD_M     (0x10)
  11633. -
  11634. -#define FDCCMDADD_E     (0x04)
  11635. -
  11636. -#define FDCCMDADD_P     (0x02)
  11637. -
  11638. -#define FDCCMDADD_A0    (0x01)
  11639. +#define FDCCMDADD_V     (0x04)   /* verify */
  11640. +#define FDCCMDADD_H     (0x08)   /* wait for spin-up */
  11641. +#define FDCCMDADD_U     (0x10)   /* update track register */
  11642. +#define FDCCMDADD_M     (0x10)   /* multiple sector access */
  11643. +#define FDCCMDADD_E     (0x04)   /* head settling flag */
  11644. +#define FDCCMDADD_P     (0x02)   /* precompensation */
  11645. +#define FDCCMDADD_A0    (0x01)   /* DAM flag */
  11646. +
  11647. +/* status register bits */
  11648. +
  11649. +#define    FDCSTAT_MOTORON    (0x80)   /* motor on */
  11650. +#define    FDCSTAT_WPROT    (0x40)   /* write protected (FDCCMD_WR*) */
  11651. +#define    FDCSTAT_SPINUP    (0x20)   /* motor speed stable (Type I) */
  11652. +#define    FDCSTAT_DELDAM    (0x20)   /* sector has deleted DAM (Type II+III) */
  11653. +#define    FDCSTAT_RECNF    (0x10)   /* record not found */
  11654. +#define    FDCSTAT_CRC        (0x08)   /* CRC error */
  11655. +#define    FDCSTAT_TR00    (0x04)   /* Track 00 flag (Type I) */
  11656. +#define    FDCSTAT_LOST    (0x04)   /* Lost Data (Type II+III) */
  11657. +#define    FDCSTAT_IDX        (0x02)   /* Index status (Type I) */
  11658. +#define    FDCSTAT_DRQ        (0x02)   /* DRQ status (Type II+III) */
  11659. +#define    FDCSTAT_BUSY    (0x01)   /* FDC is busy */
  11660.  
  11661.  
  11662.  /* PSG Port A Bit Nr 0 .. Side Sel .. 0 -> Side 1  1 -> Side 2 */
  11663. @@ -47,25 +68,12 @@
  11664.          
  11665.  #define DSKDRVNONE  (0x06)
  11666.  #define DSKDRV0     (0x02)
  11667. -#define DSKDRV1     (0x02)
  11668. -
  11669. +#define DSKDRV1     (0x04)
  11670.  
  11671. -/*
  11672. -** Misc
  11673. -*/
  11674. - 
  11675. -#define MFM_SYNC    0x4489          /* standard MFM sync value */
  11676. -
  11677. -/* Values for FD_COMMAND */
  11678. -#define FD_RECALIBRATE        0x07    /* move to track 0 */
  11679. -#define FD_SEEK            0x0F    /* seek track */
  11680. -#define FD_READ            0xE6    /* read with MT, MFM, SKip deleted */
  11681. -#define FD_WRITE        0xC5    /* write with MT, MFM */
  11682. -#define FD_SENSEI        0x08    /* Sense Interrupt Status */
  11683. -#define FD_SPECIFY        0x03    /* specify HUT etc */
  11684. -#define FD_FORMAT        0x4D    /* format one track */
  11685. -#define FD_VERSION        0x10    /* get version code */
  11686. -#define FD_CONFIGURE        0x13    /* configure FIFO operation */
  11687. -#define FD_PERPENDICULAR    0x12    /* perpendicular r/w mode */
  11688. +/* step rates */
  11689. +#define    FDCSTEP_6    0x00
  11690. +#define    FDCSTEP_12    0x01
  11691. +#define    FDCSTEP_2    0x02
  11692. +#define    FDCSTEP_3    0x03
  11693.  
  11694.  #endif
  11695. diff -ubr -x RCS -x *.[ao] -x .depend -x .version -x .config -x System.map -x vmlinux -x bootstrap -x *~ -x config.old -x *.orig -x *.rej -x *# -x version.h -x autoconf.h --new-file linux-0.9pl3/include/linux/atari_stdma.h linux-0.9pl4/include/linux/atari_stdma.h
  11696. --- linux-0.9pl3/include/linux/atari_stdma.h    Sun Aug 14 10:29:37 1994
  11697. +++ linux-0.9pl4/include/linux/atari_stdma.h    Mon Nov  7 22:33:52 1994
  11698. @@ -11,6 +11,8 @@
  11699.  void stdma_lock( isrfunc isr, void *data );
  11700.  void stdma_release( void );
  11701.  int stdma_others_waiting( void );
  11702. +int stdma_islocked( void );
  11703. +void *stdma_locked_by( void );
  11704.  void stdma_init( void );
  11705.  
  11706.  /************************* End of Prototypes **************************/
  11707. diff -ubr -x RCS -x *.[ao] -x .depend -x .version -x .config -x System.map -x vmlinux -x bootstrap -x *~ -x config.old -x *.orig -x *.rej -x *# -x version.h -x autoconf.h --new-file linux-0.9pl3/include/linux/atarihw.h linux-0.9pl4/include/linux/atarihw.h
  11708. --- linux-0.9pl3/include/linux/atarihw.h    Sun Aug 14 10:29:37 1994
  11709. +++ linux-0.9pl4/include/linux/atarihw.h    Mon Nov  7 22:33:52 1994
  11710. @@ -20,7 +20,11 @@
  11711.  
  11712.  /* Memory used for screen ram and stdma buffers */
  11713.  void atari_stram_init (void);
  11714. +#if 0
  11715.  void *atari_stram_alloc (long size);
  11716. +#else
  11717. +void *atari_stram_alloc (long size, unsigned long *start_mem );
  11718. +#endif
  11719.  void atari_stram_free (void *);
  11720.  
  11721.  /* 
  11722. diff -ubr -x RCS -x *.[ao] -x .depend -x .version -x .config -x System.map -x vmlinux -x bootstrap -x *~ -x config.old -x *.orig -x *.rej -x *# -x version.h -x autoconf.h --new-file linux-0.9pl3/include/linux/bootinfo.h linux-0.9pl4/include/linux/bootinfo.h
  11723. --- linux-0.9pl3/include/linux/bootinfo.h    Sun Aug 14 10:29:16 1994
  11724. +++ linux-0.9pl4/include/linux/bootinfo.h    Mon Nov  7 22:34:38 1994
  11725. @@ -62,8 +62,6 @@
  11726.  
  11727.  struct bi_Atari {
  11728.      AtariModel    model;
  11729. -    unsigned long stram_start;    /* Start of unmapped ST-RAM */
  11730. -    unsigned long stram_size;    /* Size of unmapped ST-RAM */
  11731.  };
  11732.  
  11733.  /*
  11734. diff -ubr -x RCS -x *.[ao] -x .depend -x .version -x .config -x System.map -x vmlinux -x bootstrap -x *~ -x config.old -x *.orig -x *.rej -x *# -x version.h -x autoconf.h --new-file linux-0.9pl3/include/linux/config.h linux-0.9pl4/include/linux/config.h
  11735. --- linux-0.9pl3/include/linux/config.h    Sun Aug 14 10:29:15 1994
  11736. +++ linux-0.9pl4/include/linux/config.h    Mon Oct 10 16:48:27 1994
  11737. @@ -15,7 +15,7 @@
  11738.   * Defines for what uname() should return
  11739.   */
  11740.  #ifndef UTS_SYSNAME
  11741. -#define UTS_SYSNAME "Linux/68k"
  11742. +#define UTS_SYSNAME "Linux"
  11743.  #endif
  11744.  
  11745.  #ifndef UTS_NODENAME
  11746. diff -ubr -x RCS -x *.[ao] -x .depend -x .version -x .config -x System.map -x vmlinux -x bootstrap -x *~ -x config.old -x *.orig -x *.rej -x *# -x version.h -x autoconf.h --new-file linux-0.9pl3/include/linux/console.h linux-0.9pl4/include/linux/console.h
  11747. --- linux-0.9pl3/include/linux/console.h    Sun Aug 14 10:29:14 1994
  11748. +++ linux-0.9pl4/include/linux/console.h    Mon Oct 24 22:27:10 1994
  11749. @@ -25,11 +25,14 @@
  11750.      unsigned char    vc_s_color;        /* Saved foreground & background */
  11751.      unsigned char    vc_ulcolor;        /* Colour for underline mode */
  11752.      unsigned char    vc_halfcolor;        /* Colour for half intensity mode */
  11753. +    unsigned short    *vc_pos;
  11754.      unsigned long    vc_x,vc_y;
  11755.      unsigned long    vc_top,vc_bottom;
  11756.      unsigned long    vc_rows,vc_cols;
  11757. +    unsigned long    vc_size_row;
  11758.      unsigned long    vc_state;
  11759.      unsigned long    vc_npar,vc_par[NPAR];
  11760. +    unsigned short    *vc_video_mem_start;
  11761.      unsigned long    vc_saved_x;
  11762.      unsigned long    vc_saved_y;
  11763.      /* mode flags */
  11764. @@ -52,6 +55,7 @@
  11765.      /* misc */
  11766.      unsigned long    vc_ques        : 1;
  11767.      unsigned long    vc_need_wrap    : 1;
  11768. +    unsigned long    vc_can_do_color    : 1;
  11769.      unsigned long    vc_tab_stop[5];        /* Tab stops. 160 columns. */
  11770.      unsigned char * vc_translate;
  11771.      unsigned char *    vc_G0_charset;
  11772. @@ -71,11 +75,11 @@
  11773.  /* DPC: 1994-04-13 !!! con_putcs is new entry !!! */
  11774.  
  11775.  struct consw {
  11776. -    long   (*con_init)(struct condata *, long);
  11777. +    long   (*con_init)(struct condata *, long, char **);
  11778.      int    (*con_deinit)(struct condata *);
  11779.      int    (*con_clear)(struct condata *, int, int, int, int);
  11780. -    int    (*con_putc)(struct condata *, int, int, int, int);
  11781. -    int    (*con_putcs)(struct condata *, const char *, int, int, int, int);
  11782. +    int    (*con_putc)(struct condata *, int, int, int);
  11783. +    int    (*con_putcs)(struct condata *, const char *, int, int, int);
  11784.      int    (*con_cursor)(struct condata *, int);
  11785.      int    (*con_scroll)(struct condata *, int, int, int, int);
  11786.      int    (*con_bmove)(struct condata *, int, int, int, int, int, int);
  11787. @@ -88,12 +92,6 @@
  11788.  
  11789.  /* flag bits */
  11790.  #define CON_INITED  (1)
  11791. -
  11792. -/* definitions for draw mode */
  11793. -#define DM_CLEAR    (1)
  11794. -#define DM_COPY     (2)
  11795. -#define DM_XOR      (3)
  11796. -#define DM_INVERSE  (4)
  11797.  
  11798.  /* scroll */
  11799.  #define SM_UP       (1)
  11800. diff -ubr -x RCS -x *.[ao] -x .depend -x .version -x .config -x System.map -x vmlinux -x bootstrap -x *~ -x config.old -x *.orig -x *.rej -x *# -x version.h -x autoconf.h --new-file linux-0.9pl3/include/linux/kd.h linux-0.9pl4/include/linux/kd.h
  11801. --- linux-0.9pl3/include/linux/kd.h    Sun Aug 14 10:29:15 1994
  11802. +++ linux-0.9pl4/include/linux/kd.h    Mon Nov  7 22:36:01 1994
  11803. @@ -212,4 +212,5 @@
  11804.  /* note: 0x4B60 and 0x4B61 used above for GIO_FONT and PIO_FONT
  11805.           0x4B62 and 0x4B63 used above for KDGKBMETA and KDSKBMETA */
  11806.  
  11807. +#define GET_SCRADDR    0x4b70    /* get the start of screen mem */
  11808.  #endif /* _LINUX_KD_H */
  11809. diff -ubr -x RCS -x *.[ao] -x .depend -x .version -x .config -x System.map -x vmlinux -x bootstrap -x *~ -x config.old -x *.orig -x *.rej -x *# -x version.h -x autoconf.h --new-file linux-0.9pl3/include/linux/keyboard.h linux-0.9pl4/include/linux/keyboard.h
  11810. --- linux-0.9pl3/include/linux/keyboard.h    Sun Aug 14 10:29:33 1994
  11811. +++ linux-0.9pl4/include/linux/keyboard.h    Thu Nov 24 21:21:52 1994
  11812. @@ -18,14 +18,18 @@
  11813.  
  11814.  #define NR_KEYS 128
  11815.  #define NR_KEYMAPS 16
  11816. +#ifdef __KERNEL__
  11817.  extern const int NR_TYPES;
  11818.  extern const int max_vals[];
  11819.  extern unsigned short (*key_map)[NR_KEYS];
  11820. +#endif
  11821.  
  11822.  #define NR_FUNC 36
  11823.  #define FUNC_BUFSIZE 512
  11824. +#ifdef __KERNEL__
  11825.  extern char func_buf[FUNC_BUFSIZE];
  11826.  extern char *func_table[NR_FUNC];
  11827. +#endif
  11828.  
  11829.  #define KT_LATIN    0    /* we depend on this being zero */
  11830.  #define KT_LETTER      11    /* symbol that can be acted upon by CapsLock */
  11831. diff -ubr -x RCS -x *.[ao] -x .depend -x .version -x .config -x System.map -x vmlinux -x bootstrap -x *~ -x config.old -x *.orig -x *.rej -x *# -x version.h -x autoconf.h --new-file linux-0.9pl3/include/linux/major.h linux-0.9pl4/include/linux/major.h
  11832. --- linux-0.9pl3/include/linux/major.h    Sun Aug 14 10:29:14 1994
  11833. +++ linux-0.9pl4/include/linux/major.h    Mon Nov  7 22:36:52 1994
  11834. @@ -45,6 +45,7 @@
  11835.   * 25 -                        matsushita cdrom       minors 0..3
  11836.   * 26 -
  11837.   * 27 - qic117 tape
  11838. + * 28 -                   acsi disk
  11839.   */
  11840.  
  11841.  #define UNNAMED_MAJOR    0
  11842. @@ -73,6 +74,7 @@
  11843.  #define CDU535_CDROM_MAJOR 24
  11844.  #define MATSUSHITA_CDROM_MAJOR 25
  11845.  #define QIC117_TAPE_MAJOR 27
  11846. +#define ACSI_MAJOR    28
  11847.  
  11848.  /*
  11849.   * Tests for SCSI devices.
  11850. diff -ubr -x RCS -x *.[ao] -x .depend -x .version -x .config -x System.map -x vmlinux -x bootstrap -x *~ -x config.old -x *.orig -x *.rej -x *# -x version.h -x autoconf.h --new-file linux-0.9pl3/include/linux/mm.h linux-0.9pl4/include/linux/mm.h
  11851. --- linux-0.9pl3/include/linux/mm.h    Sun Aug 28 17:16:17 1994
  11852. +++ linux-0.9pl4/include/linux/mm.h    Mon Nov 21 18:34:17 1994
  11853. @@ -19,6 +19,7 @@
  11854.  #include <linux/sched.h>
  11855.  #include <linux/errno.h>
  11856.  #include <linux/kernel.h>
  11857. +#include <asm/segment.h>
  11858.  
  11859.  #define VERIFY_READ 0
  11860.  #define VERIFY_WRITE 1
  11861. @@ -33,10 +34,12 @@
  11862.      if (size > TASK_SIZE - (unsigned long) addr)
  11863.          return -EFAULT;
  11864.  #elif defined(__mc68000__)
  11865. -    if (current->pid != 1 && TASK_SIZE <= (unsigned long) addr)
  11866. +    if (current->pid != 1 && get_fs () != get_ds ()) {
  11867. +        if (TASK_SIZE <= (unsigned long) addr)
  11868.          return -EFAULT;
  11869. -    if (current->pid != 1 && size > TASK_SIZE - (unsigned long) addr)
  11870. +        if (size > TASK_SIZE - (unsigned long) addr)
  11871.          return -EFAULT;
  11872. +    }
  11873.  #endif
  11874.      if (wp_works_ok || type == VERIFY_READ || !size)
  11875.          return 0;
  11876. diff -ubr -x RCS -x *.[ao] -x .depend -x .version -x .config -x System.map -x vmlinux -x bootstrap -x *~ -x config.old -x *.orig -x *.rej -x *# -x version.h -x autoconf.h --new-file linux-0.9pl3/include/linux/nfs_fs.h linux-0.9pl4/include/linux/nfs_fs.h
  11877. --- linux-0.9pl3/include/linux/nfs_fs.h    Wed Dec 31 19:00:00 1969
  11878. +++ linux-0.9pl4/include/linux/nfs_fs.h    Wed Dec  1 07:44:15 1993
  11879. @@ -0,0 +1,124 @@
  11880. +#ifndef _LINUX_NFS_FS_H
  11881. +#define _LINUX_NFS_FS_H
  11882. +
  11883. +/*
  11884. + *  linux/include/linux/nfs_fs.h
  11885. + *
  11886. + *  Copyright (C) 1992  Rick Sladkey
  11887. + *
  11888. + *  OS-specific nfs filesystem definitions and declarations
  11889. + */
  11890. +
  11891. +#include <linux/nfs.h>
  11892. +
  11893. +#include <linux/in.h>
  11894. +#include <linux/nfs_mount.h>
  11895. +
  11896. +/*
  11897. + * The readdir cache size controls how many directory entries are cached.
  11898. + * Its size is limited by the number of nfs_entry structures that can fit
  11899. + * in one 4096-byte page, currently 256.
  11900. + */
  11901. +
  11902. +#define NFS_READDIR_CACHE_SIZE        64
  11903. +
  11904. +/*
  11905. + * WARNING!  The I/O buffer size cannot be bigger than about 3900 for now.
  11906. + * It needs to fit inside a 4096-byte page and leave room for the RPC and
  11907. + * NFS headers.  But it ought to at least be a multiple of 512 and probably
  11908. + * should be a power of 2.  I don't think Linux TCP/IP can handle more than
  11909. + * about 1800 yet.
  11910. + */
  11911. +
  11912. +#define NFS_MAX_FILE_IO_BUFFER_SIZE    (7*512)
  11913. +#define NFS_DEF_FILE_IO_BUFFER_SIZE    1024
  11914. +
  11915. +/*
  11916. + * The upper limit on timeouts for the exponential backoff algorithm
  11917. + * in tenths of a second.
  11918. + */
  11919. +
  11920. +#define NFS_MAX_RPC_TIMEOUT        600
  11921. +
  11922. +/*
  11923. + * Size of the lookup cache in units of number of entries cached.
  11924. + * It is better not to make this too large although the optimimum
  11925. + * depends on a usage and environment.
  11926. + */
  11927. +
  11928. +#define NFS_LOOKUP_CACHE_SIZE        64
  11929. +
  11930. +#define NFS_SUPER_MAGIC            0x6969
  11931. +
  11932. +#define NFS_SERVER(inode)        (&(inode)->i_sb->u.nfs_sb.s_server)
  11933. +#define NFS_FH(inode)            (&(inode)->u.nfs_i.fhandle)
  11934. +
  11935. +/* linux/fs/nfs/proc.c */
  11936. +
  11937. +extern int nfs_proc_getattr(struct nfs_server *server, struct nfs_fh *fhandle,
  11938. +                struct nfs_fattr *fattr);
  11939. +extern int nfs_proc_setattr(struct nfs_server *server, struct nfs_fh *fhandle,
  11940. +                struct nfs_sattr *sattr, struct nfs_fattr *fattr);
  11941. +extern int nfs_proc_lookup(struct nfs_server *server, struct nfs_fh *dir,
  11942. +               const char *name, struct nfs_fh *fhandle,
  11943. +               struct nfs_fattr *fattr);
  11944. +extern int nfs_proc_readlink(struct nfs_server *server, struct nfs_fh *fhandle,
  11945. +                 char *res);
  11946. +extern int nfs_proc_read(struct nfs_server *server, struct nfs_fh *fhandle,
  11947. +             int offset, int count, char *data,
  11948. +             struct nfs_fattr *fattr);
  11949. +extern int nfs_proc_write(struct nfs_server *server, struct nfs_fh *fhandle,
  11950. +              int offset, int count, char *data,
  11951. +              struct nfs_fattr *fattr);
  11952. +extern int nfs_proc_create(struct nfs_server *server, struct nfs_fh *dir,
  11953. +               const char *name, struct nfs_sattr *sattr,
  11954. +               struct nfs_fh *fhandle, struct nfs_fattr *fattr);
  11955. +extern int nfs_proc_remove(struct nfs_server *server, struct nfs_fh *dir,
  11956. +               const char *name);
  11957. +extern int nfs_proc_rename(struct nfs_server *server,
  11958. +               struct nfs_fh *old_dir, const char *old_name,
  11959. +               struct nfs_fh *new_dir, const char *new_name);
  11960. +extern int nfs_proc_link(struct nfs_server *server, struct nfs_fh *fhandle,
  11961. +             struct nfs_fh *dir, const char *name);
  11962. +extern int nfs_proc_symlink(struct nfs_server *server, struct nfs_fh *dir,
  11963. +                const char *name, const char *path, struct nfs_sattr *sattr);
  11964. +extern int nfs_proc_mkdir(struct nfs_server *server, struct nfs_fh *dir,
  11965. +              const char *name, struct nfs_sattr *sattr,
  11966. +              struct nfs_fh *fhandle, struct nfs_fattr *fattr);
  11967. +extern int nfs_proc_rmdir(struct nfs_server *server, struct nfs_fh *dir,
  11968. +              const char *name);
  11969. +extern int nfs_proc_readdir(struct nfs_server *server, struct nfs_fh *fhandle,
  11970. +                int cookie, int count, struct nfs_entry *entry);
  11971. +extern int nfs_proc_statfs(struct nfs_server *server, struct nfs_fh *fhandle,
  11972. +                struct nfs_fsinfo *res);
  11973. +
  11974. +/* linux/fs/nfs/sock.c */
  11975. +
  11976. +extern int nfs_rpc_call(struct nfs_server *server, int *start, int *end);
  11977. +
  11978. +/* linux/fs/nfs/inode.c */
  11979. +
  11980. +extern struct super_block *nfs_read_super(struct super_block *sb, 
  11981. +                      void *data,int);
  11982. +extern struct inode *nfs_fhget(struct super_block *sb, struct nfs_fh *fhandle,
  11983. +                   struct nfs_fattr *fattr);
  11984. +extern void nfs_refresh_inode(struct inode *inode, struct nfs_fattr *fattr);
  11985. +
  11986. +/* linux/fs/nfs/file.c */
  11987. +
  11988. +extern struct inode_operations nfs_file_inode_operations;
  11989. +
  11990. +/* linux/fs/nfs/dir.c */
  11991. +
  11992. +extern struct inode_operations nfs_dir_inode_operations;
  11993. +
  11994. +/* linux/fs/nfs/symlink.c */
  11995. +
  11996. +extern struct inode_operations nfs_symlink_inode_operations;
  11997. +
  11998. +/* linux/fs/nfs/mmap.c */
  11999. +
  12000. +extern int nfs_mmap(struct inode * inode, struct file * file,
  12001. +               unsigned long addr, size_t len, int prot, unsigned long off);
  12002. +
  12003. +#endif
  12004. diff -ubr -x RCS -x *.[ao] -x .depend -x .version -x .config -x System.map -x vmlinux -x bootstrap -x *~ -x config.old -x *.orig -x *.rej -x *# -x version.h -x autoconf.h --new-file linux-0.9pl3/include/linux/nfs_mount.h linux-0.9pl4/include/linux/nfs_mount.h
  12005. --- linux-0.9pl3/include/linux/nfs_mount.h    Wed Dec 31 19:00:00 1969
  12006. +++ linux-0.9pl4/include/linux/nfs_mount.h    Wed Dec  1 07:44:15 1993
  12007. @@ -0,0 +1,48 @@
  12008. +#ifndef _LINUX_NFS_MOUNT_H
  12009. +#define _LINUX_NFS_MOUNT_H
  12010. +
  12011. +/*
  12012. + *  linux/include/linux/nfs_mount.h
  12013. + *
  12014. + *  Copyright (C) 1992  Rick Sladkey
  12015. + *
  12016. + *  structure passed from user-space to kernel-space during an nfs mount
  12017. + */
  12018. +
  12019. +/*
  12020. + * WARNING!  Do not delete or change the order of these fields.  If
  12021. + * a new field is required then add it to the end.  The version field
  12022. + * tracks which fields are present.  This will ensure some measure of
  12023. + * mount-to-kernel version compatibilty.  Some of these aren't used yet
  12024. + * but here they are anyway.
  12025. + */
  12026. +
  12027. +#define NFS_MOUNT_VERSION    1    /* current version */
  12028. +
  12029. +struct nfs_mount_data {
  12030. +    int version;            /* 1 */
  12031. +    int fd;                /* 1 */
  12032. +    struct nfs_fh root;        /* 1 */
  12033. +    int flags;            /* 1 */
  12034. +    int rsize;            /* 1 */
  12035. +    int wsize;            /* 1 */
  12036. +    int timeo;            /* 1 */
  12037. +    int retrans;            /* 1 */
  12038. +    int acregmin;            /* 1 */
  12039. +    int acregmax;            /* 1 */
  12040. +    int acdirmin;            /* 1 */
  12041. +    int acdirmax;            /* 1 */
  12042. +    struct sockaddr_in addr;    /* 1 */
  12043. +    char hostname[256];        /* 1 */
  12044. +};
  12045. +
  12046. +/* bits in the flags field */
  12047. +
  12048. +#define NFS_MOUNT_SOFT        0x0001    /* 1 */
  12049. +#define NFS_MOUNT_INTR        0x0002    /* 1 */
  12050. +#define NFS_MOUNT_SECURE    0x0004    /* 1 */
  12051. +#define NFS_MOUNT_POSIX        0x0008    /* 1 */
  12052. +#define NFS_MOUNT_NOCTO        0x0010    /* 1 */
  12053. +#define NFS_MOUNT_NOAC        0x0020    /* 1 */
  12054. + 
  12055. +#endif
  12056. diff -ubr -x RCS -x *.[ao] -x .depend -x .version -x .config -x System.map -x vmlinux -x bootstrap -x *~ -x config.old -x *.orig -x *.rej -x *# -x version.h -x autoconf.h --new-file linux-0.9pl3/include/linux/wait.h linux-0.9pl4/include/linux/wait.h
  12057. --- linux-0.9pl3/include/linux/wait.h    Sun Aug 14 10:29:35 1994
  12058. +++ linux-0.9pl4/include/linux/wait.h    Sat Nov  5 11:41:43 1994
  12059. @@ -23,6 +23,7 @@
  12060.  };
  12061.  
  12062.  #define MUTEX ((struct semaphore) { 1, NULL })
  12063. +#define MUTEX_LOCKED ((struct semaphore) { 0, NULL })
  12064.  
  12065.  struct select_table_entry {
  12066.      struct wait_queue wait;
  12067. diff -ubr -x RCS -x *.[ao] -x .depend -x .version -x .config -x System.map -x vmlinux -x bootstrap -x *~ -x config.old -x *.orig -x *.rej -x *# -x version.h -x autoconf.h --new-file linux-0.9pl3/init/main.c linux-0.9pl4/init/main.c
  12068. --- linux-0.9pl3/init/main.c    Sun Aug 14 10:29:10 1994
  12069. +++ linux-0.9pl4/init/main.c    Thu Nov 24 22:17:11 1994
  12070. @@ -164,6 +164,7 @@
  12071.  static char command_line[COMMAND_LINE_SIZE] = { 0, };
  12072.  
  12073.  struct bootinfo boot_info = {0,};
  12074. +int bisize = sizeof boot_info;
  12075.  
  12076.  char *get_options(char *str, int *ints)
  12077.  {
  12078. @@ -329,7 +330,7 @@
  12079.              for (n = 0 ; devnames[n] ; n++) {
  12080.                  int len = strlen(devnames[n]);
  12081.                  if (!strncmp(line,devnames[n],len)) {
  12082. -                    ROOT_DEV = devnums[n]+simple_strtoul(line+len,NULL,16);
  12083. +                    ROOT_DEV = devnums[n]+simple_strtoul(line+len,NULL,10);
  12084.                      break;
  12085.                  }
  12086.              }
  12087. @@ -561,7 +562,7 @@
  12088.  #ifdef __i386__
  12089.      sprintf(term, "TERM=con%dx%d", ORIG_VIDEO_COLS, ORIG_VIDEO_LINES);
  12090.  #else
  12091. -    sprintf(term, "TERM=vt100");
  12092. +    sprintf(term, "TERM=console");
  12093.  #endif
  12094.      (void) open("/dev/tty1",O_RDWR,0);
  12095.      (void) dup(0);
  12096. @@ -576,6 +577,7 @@
  12097.          close(0);
  12098.          if (open("/etc/rc",O_RDONLY,0))
  12099.              _exit(1);
  12100. +
  12101.          execve("/bin/sh",argv_rc,envp_rc);
  12102.          _exit(2);
  12103.      }
  12104. @@ -595,6 +597,7 @@
  12105.              (void) dup(0);
  12106.              _exit(execve("/bin/sh",argv,envp));
  12107.          }
  12108. +
  12109.          while (1)
  12110.              if (pid == wait(&i))
  12111.                  break;
  12112. diff -ubr -x RCS -x *.[ao] -x .depend -x .version -x .config -x System.map -x vmlinux -x bootstrap -x *~ -x config.old -x *.orig -x *.rej -x *# -x version.h -x autoconf.h --new-file linux-0.9pl3/kernel/printk.c linux-0.9pl4/kernel/printk.c
  12113. --- linux-0.9pl3/kernel/printk.c    Sun Aug 14 10:30:34 1994
  12114. +++ linux-0.9pl4/kernel/printk.c    Mon Nov 21 18:09:04 1994
  12115. @@ -179,7 +179,10 @@
  12116.              if (log_size < LOG_BUF_LEN)
  12117.                  log_size++;
  12118.              else
  12119. +              {
  12120.                  log_start++;
  12121. +                log_start &= LOG_BUF_LEN - 1;
  12122. +              }
  12123.              logged_chars++;
  12124.              if (*p == '\n')
  12125.                  break;
  12126. diff -ubr -x RCS -x *.[ao] -x .depend -x .version -x .config -x System.map -x vmlinux -x bootstrap -x *~ -x config.old -x *.orig -x *.rej -x *# -x version.h -x autoconf.h --new-file linux-0.9pl3/m68k/head.S linux-0.9pl4/m68k/head.S
  12127. --- linux-0.9pl3/m68k/head.S    Tue Sep 27 22:24:23 1994
  12128. +++ linux-0.9pl4/m68k/head.S    Mon Nov 21 18:30:44 1994
  12129. @@ -9,6 +9,9 @@
  12130.  ** Atari support by Andreas Schwab, using ideas of Robert de Vries
  12131.  ** and Bjoern Brauel
  12132.  **
  12133. +** 94/11/14 Andreas Schwab: put kernel at KSTART_ADDR + PAGESIZE
  12134. +** 94/11/18 Andreas Schwab: remove identity mapping of STRAM for Atari 
  12135. +**
  12136.  ** This file is subject to the terms and conditions of the GNU General Public
  12137.  ** License.  See the file README.legal in the main directory of this archive
  12138.  ** for more details.
  12139. @@ -37,7 +40,7 @@
  12140.   */
  12141.  
  12142.  .text
  12143. -.globl _start, _krt, _kpt, _availmem
  12144. +.globl _krt, _kpt, _availmem
  12145.  
  12146.  PAGESIZE = 4096
  12147.  KSTART_ADDR = 0xC0000000
  12148. @@ -103,6 +106,24 @@
  12149.      movel    d0,sp
  12150.  
  12151.  /*
  12152. + * Copy bootinfo from position after BSS to final resting place
  12153. + */
  12154. +    lea    pc@(_end),a0
  12155. +    lea    pc@(_boot_info),a1
  12156. +    movel    pc@(_bisize),d0
  12157. +    subql    #1,d0
  12158. +1:    moveb    a0@+,a1@+
  12159. +    dbra    d0,1b
  12160. +
  12161. +/*
  12162. + * Record the CPU and machine type.
  12163. + */
  12164. +    lea    pc@(_boot_info),a0
  12165. +    lea    pc@(_end),a0
  12166. +    movel    a0@(BI_CPU),d6
  12167. +    movel    a0@(BI_MACH),d4
  12168. +
  12169. +/*
  12170.   * Initialize serial port
  12171.   */
  12172.      bsr Lserial_init
  12173. @@ -115,13 +136,6 @@
  12174.      bsr    Lserial_putc
  12175.  
  12176.  /*
  12177. - * Record the CPU and machine type.
  12178. - */
  12179. -    lea    pc@(_boot_info),a0
  12180. -    movel    a0@(BI_CPU),d6
  12181. -    movel    a0@(BI_MACH),d4
  12182. -
  12183. -/*
  12184.   * Get address at end of kernel code/data/bss and
  12185.   * mask off at a page boundary.
  12186.   */
  12187. @@ -197,7 +211,7 @@
  12188.      bnes    1f
  12189.  
  12190.      /* 680[23]0 */
  12191. -    lea    pc@(_start:w),a1  /* base address */
  12192. +    lea    pc@(_start-PAGESIZE:w),a1  /* base address */
  12193.      addql    #PAGEDESC,a1    /* descriptor type */
  12194.      movel    #0x40000,d2    /* increment */
  12195.      bras    2f
  12196. @@ -232,7 +246,7 @@
  12197.      bsr    Lserial_putc
  12198.  
  12199.      movel    pc@(_kpt),a0
  12200. -    lea    pc@(_start),a1
  12201. +    lea    pc@(_start-PAGESIZE:w),a1
  12202.      addw    #(GLOBAL+CM_CACHE_CB+PAGEDESC),a1
  12203.      movew    #((PAGESIZE/4)-1),d1
  12204.      movel    #PAGESIZE,d2
  12205. @@ -248,7 +262,7 @@
  12206.       * all pointer tables utilitized thus far) and the
  12207.       * kernel page table.
  12208.       */
  12209. -    lea    pc@(_start),a0
  12210. +    lea    pc@(_start-PAGESIZE:w),a0
  12211.      movel    a5,d0        /* address of root table */
  12212.      subl    a0,d0        /* determine offset of root table page */
  12213.      moveq    #PAGE_INDEX_SHIFT,d1    /* determine offset into kernel page table */
  12214. @@ -356,7 +370,7 @@
  12215.       * noncachable/serialized.
  12216.       */
  12217.      movel    a3,d0        /* ami page table start address */
  12218. -    lea    pc@(_start:w),a0
  12219. +    lea    pc@(_start-PAGESIZE:w),a0
  12220.      subl    a0,d0        /* determine offset of root table page */
  12221.      moveq    #12,d1        /* determine offset into kernel page table */
  12222.      lsrl    d1,d0
  12223. @@ -381,10 +395,10 @@
  12224.  
  12225.  /* On the Atari, duplicate the i/o region at 0xfffxxxxx and
  12226.     mark it non-cachable, set up an identity translation of the first
  12227. -   16M.  We need two additional page tables for this */
  12228. +   16M.  We need two additional pointer tables for this */
  12229.  
  12230.      lea    a5@(1024),a0
  12231. -    addl    #2,a0
  12232. +    addl    #TABLEDESC,a0
  12233.      movel    a0,a5@(508)        /* 0xFE000000 - 0xFFFFFFFF */
  12234.  
  12235.      lea     a5@(1024),a0
  12236. @@ -393,8 +407,8 @@
  12237.  1:    movel    d0,a0@+
  12238.      dbra    d2,1b
  12239.  
  12240. -/* Identity mapping of the last 16M of virtual address space
  12241. -   to the first 16M for efficient addressing of hardware registers */
  12242. +/* Mapping of the last 16M of virtual address space to the first 16M
  12243. +   for efficient addressing of hardware registers */
  12244.      movel    #0x40000,d1
  12245.      movel    #63,d2
  12246.      movel    #PAGEDESC,d0
  12247. @@ -409,6 +423,7 @@
  12248.      lea    a5@(1536+TABLEDESC),a0
  12249.      movel    a0,a5@
  12250.  
  12251. +#if 0 /* this is not needed any more */
  12252.  /* Identity mapping of the first 16M of virtual address space */
  12253.      lea    a5@(1536),a0
  12254.      movel    #PAGEDESC,d0
  12255. @@ -427,6 +442,7 @@
  12256.      movel    #63,d2
  12257.  1:    movel    d0,a0@+
  12258.      dbra    d2,1b
  12259. +#endif
  12260.  
  12261.      bra    Lmapphys
  12262.  
  12263. @@ -462,7 +478,7 @@
  12264.                   */
  12265.  
  12266.  2:
  12267. -    lea    pc@(_start:w),a0  /* get address of start of memory */
  12268. +    lea    pc@(_start-PAGESIZE:w),a0  /* get address of start of memory */
  12269.      cmpl    a0,d0        /* compare limit to start */
  12270.      bhi    Lnophys
  12271.  
  12272. @@ -478,7 +494,7 @@
  12273.       * in the root table.  a0 contains the start address of the
  12274.       * kernel.
  12275.       */
  12276. -    lea    pc@(_start:w),a0
  12277. +    lea    pc@(_start-PAGESIZE:w),a0
  12278.      movel    a0,d2
  12279.      moveq    #25,d3        /* find appropriate index in root table */
  12280.      lsrl    d3,d2
  12281. @@ -493,7 +509,7 @@
  12282.       * registers to identity map the 16M chunk that contains
  12283.       * the physical memory.
  12284.       */
  12285. -    lea    pc@(_start:w),a0
  12286. +    lea    pc@(_start-PAGESIZE:w),a0
  12287.      movel    a0,d2
  12288.      andl    #0xff000000,d2        /* logical address base */
  12289.      orw    #0xc040,d2        /* add in magic bits */
  12290. @@ -504,31 +520,20 @@
  12291.      cmpl    #MACH_ATARI,d4
  12292.      bnes    Lnophys2
  12293.  
  12294. -    /* if kernel runs in tt-ram, identity map its address space,
  12295. -       to be removed later */
  12296. -
  12297. -    lea    pc@(_start:w),a1
  12298. -    cmpl    #0x1000000,a1
  12299. -    bcs    Lnophys2
  12300. +    /* Temporarily set up an identity mapping of the 32MB chunk
  12301. +       where the kernel is executing */
  12302.  
  12303.      /* cleanup is needed; note it */
  12304.      moveq    #1,d5
  12305.  
  12306. -    /* this assumes that the kernel is in the first 12M of tt-ram,
  12307. -       otherwise we would have to set up an additional pointer table */
  12308. -    movel    a1,d2
  12309. -    moveq    #18,d3        /* find appropriate index in pointer table */
  12310. +    lea    pc@(_start-PAGESIZE:w),a0
  12311. +    movel    a0,d2
  12312. +    moveq    #25,d3        /* find appropriate index in root table */
  12313.      lsrl    d3,d2
  12314.      movel    d2,d0
  12315.      lsll    d3,d0        /* convert address into descriptor */
  12316.      addql    #PAGEDESC,d0
  12317. -    movel    #1<<18,d1
  12318. -    lea    a5@(1536),a0
  12319. -    lea    a0@(d2:l:4),a0
  12320. -    moveq    #15,d2
  12321. -1:    movel    d0,a0@+        /* store mapping */
  12322. -    addl    d1,d0
  12323. -    dbra    d2,1b
  12324. +    movel    d0,a5@(d2:l:4)  /* store mapping */
  12325.  
  12326.  Lnophys2:
  12327.  
  12328. @@ -542,7 +547,7 @@
  12329.      moveq    #'K',d7
  12330.      bsr    Lserial_putc
  12331.  
  12332. -    lea    pc@(Lmmu),a0
  12333. +    lea    pc@(mmu),a0
  12334.      movel    #0x80000002,a0@   /* no limit, 4byte descriptors */
  12335.      movel    a5,a0@(4)
  12336.      pmove    a0@,srp
  12337. @@ -577,7 +582,7 @@
  12338.      bsr    Lserial_putc
  12339.  
  12340.      movel    #KSTART_ADDR,d0
  12341. -    lea    pc@(_start:w),a0
  12342. +    lea    pc@(_start-PAGESIZE:w),a0
  12343.  
  12344.      movel    _kpt,d1
  12345.      subl    a0,d1
  12346. @@ -609,7 +614,7 @@
  12347.       lea       pc@(tmp_fault_handler),a0
  12348.       move.l    a0,8                     /* Access fault vector */
  12349.  
  12350. -    lea    pc@(_start:w),a0
  12351. +    lea    pc@(_start-PAGESIZE:w),a0
  12352.      jmp    Lvirt:l
  12353.  
  12354.  Lvirt:
  12355. @@ -628,30 +633,17 @@
  12356.  
  12357.      /* clean up physical identity mapping for 68020/68030 */
  12358.      cmpl    #MACH_AMIGA,d4
  12359. -    bne    Lnoamiclean
  12360. +    beqs    Lclean030
  12361. +    cmpl    #MACH_ATARI,d4
  12362. +    bnes    Lnoclean
  12363.  
  12364. +Lclean030:
  12365.      movel    a0,d2        /* a0 contains physical start address */
  12366.      moveq    #25,d3        /* find appropriate index in root table */
  12367.      lsrl    d3,d2
  12368.      moveq    #0,d0
  12369.      movel    d0,a5@(d2:l:4)  /* clear descriptor */
  12370.  
  12371. -Lnoamiclean:
  12372. -
  12373. -    cmpl    #MACH_ATARI,d4
  12374. -    bne    Lnoclean
  12375. -
  12376. -    movel    a0,d2        /* a0 contains physical start address */
  12377. -    moveq    #18,d3        /* find appropriate index in pointer table */
  12378. -    lsrl    d3,d2
  12379. -    moveq    #0,d0
  12380. -    lea    a5@(1536),a1
  12381. -    lea    a1@(d2:l:4),a1
  12382. -    moveq    #15,d5
  12383. -1:    movel    d0,a1@+        /* clear descriptor */
  12384. -    dbra    d5,1b
  12385. -
  12386. -    pflusha         /* flush address translation cache */
  12387.      bras    Lnoclean
  12388.  
  12389.  Loff040:
  12390. @@ -956,7 +948,7 @@
  12391.      moveq    #'=',d7
  12392.      bsr    Lserial_putc
  12393.  
  12394. -    lea    pc@(Lmmu),a1
  12395. +    lea    pc@(mmu),a1
  12396.      pmove    psr,a1@
  12397.      clrl    d7
  12398.      movew    a1@,d7
  12399. @@ -971,7 +963,7 @@
  12400.      rts
  12401.  
  12402.      .data
  12403. -Lmmu:    .quad 0
  12404. +mmu:    .quad 0
  12405.  _krt:    .long 0
  12406.  _kpt:    .long 0
  12407.  _availmem:
  12408. diff -ubr -x RCS -x *.[ao] -x .depend -x .version -x .config -x System.map -x vmlinux -x bootstrap -x *~ -x config.old -x *.orig -x *.rej -x *# -x version.h -x autoconf.h --new-file linux-0.9pl3/m68k/ints.c linux-0.9pl4/m68k/ints.c
  12409. --- linux-0.9pl3/m68k/ints.c    Sun Aug 14 10:29:37 1994
  12410. +++ linux-0.9pl4/m68k/ints.c    Sat Nov 12 09:51:47 1994
  12411. @@ -167,7 +167,7 @@
  12412.      }
  12413.  }
  12414.  
  12415. -#define    DEBUG_LOST_INT_DECR
  12416. +#undef DEBUG_LOST_INT_DECR
  12417.  
  12418.  asmlinkage void process_int(int level, struct intframe *fp)
  12419.  {
  12420. diff -ubr -x RCS -x *.[ao] -x .depend -x .version -x .config -x System.map -x vmlinux -x bootstrap -x *~ -x config.old -x *.orig -x *.rej -x *# -x version.h -x autoconf.h --new-file linux-0.9pl3/m68k/signal.c linux-0.9pl4/m68k/signal.c
  12421. --- linux-0.9pl3/m68k/signal.c    Sun Aug 14 10:29:37 1994
  12422. +++ linux-0.9pl4/m68k/signal.c    Thu Oct 20 22:51:01 1994
  12423. @@ -308,6 +308,40 @@
  12424.              current->state = TASK_STOPPED;
  12425.              notify_parent(current);
  12426.              schedule();
  12427. +            /* ++andreas: discard the extra stuff from the
  12428. +               stack frame and always return with a four-word
  12429. +               frame. */
  12430. +            switch (regs->format)
  12431. +              {
  12432. +              case 0:
  12433. +                break;
  12434. +              case 2:
  12435. +                regs->stkadj = sizeof (regs->un.fmt2);
  12436. +                break;
  12437. +              case 3:
  12438. +                regs->stkadj = sizeof (regs->un.fmt3);
  12439. +                break;
  12440. +              case 4:
  12441. +                regs->stkadj = sizeof (regs->un.fmt4);
  12442. +                break;
  12443. +              case 7:
  12444. +                regs->stkadj = sizeof (regs->un.fmt7);
  12445. +                break;
  12446. +              case 9:
  12447. +                regs->stkadj = sizeof (regs->un.fmt9);
  12448. +                break;
  12449. +              case 10:
  12450. +                regs->stkadj = sizeof (regs->un.fmta);
  12451. +                break;
  12452. +              case 11:
  12453. +                regs->stkadj = sizeof (regs->un.fmtb);
  12454. +                break;
  12455. +              default:
  12456. +                printk ("do_signal: Unknown frame format %#x\n",
  12457. +                    regs->format);
  12458. +                do_exit (SIGSEGV);
  12459. +              }
  12460. +            regs->format = 0;
  12461.              if (!(signr = current->exit_code))
  12462.                  continue;
  12463.              current->exit_code = 0;
  12464. @@ -374,7 +408,23 @@
  12465.          regs->pc -= 2;
  12466.      }
  12467.      if (!handler_signal)    /* no handler will be called - return 0 */
  12468. +      {
  12469. +        /* If we are about to discard some frame stuff we must
  12470. +           copy over the remaining frame. */
  12471. +        if (regs->stkadj)
  12472. +          {
  12473. +        struct frame *tregs =
  12474. +          (struct frame *) ((ulong) regs + regs->stkadj);
  12475. +
  12476. +        /* This must be copied with decreasing addresses to
  12477. +           handle overlaps.  */
  12478. +        tregs->format = regs->format;
  12479. +        tregs->vector = regs->vector;
  12480. +        tregs->pc = regs->pc;
  12481. +        tregs->sr = regs->sr;
  12482. +          }
  12483.          return 0;
  12484. +      }
  12485.      pc = regs->pc;
  12486.      frame = (unsigned long *)regs->usp;
  12487.      signr = 1;
  12488. diff -ubr -x RCS -x *.[ao] -x .depend -x .version -x .config -x System.map -x vmlinux -x bootstrap -x *~ -x config.old -x *.orig -x *.rej -x *# -x version.h -x autoconf.h --new-file linux-0.9pl3/m68k/sys_call.S linux-0.9pl4/m68k/sys_call.S
  12489. --- linux-0.9pl3/m68k/sys_call.S    Sun Aug 28 17:16:21 1994
  12490. +++ linux-0.9pl4/m68k/sys_call.S    Sat Nov 12 09:52:25 1994
  12491. @@ -90,6 +90,17 @@
  12492.  LTS_FLAGS    = 20
  12493.  LTS_ERRNO    = 24
  12494.  
  12495. +#include <linux/autoconf.h>
  12496. +
  12497. +/* the following macro is used when enabling interrupts */
  12498. +#if defined(CONFIG_ATARI) && !defined(CONFIG_AMIGA) && !defined(CONFIG_MAC)
  12499. +    /* block out HSYNC on the atari */
  12500. +#define ALLOWINT 0xfbff
  12501. +#else
  12502. +    /* portable version */
  12503. +#define ALLOWINT 0xf8ff
  12504. +#endif /* machine compilation types */ 
  12505. +
  12506.  .globl _system_call, _buserr, _trap
  12507.  .globl _ret_from_exception, _inthandler
  12508.  
  12509. @@ -280,12 +291,12 @@
  12510.      bne    1f
  12511.  
  12512.      movel    _bh_mask,d0
  12513. -    andl    d0,_bh_active
  12514. +    andl    _bh_active,d0
  12515.      beq    1f
  12516.  
  12517.      movew    sr,sp@-
  12518.      addql    #1,_intr_count
  12519. -    andiw    #0xf8ff,sr        | allow interrupts
  12520. +    andiw    #(ALLOWINT),sr        | allow interrupts
  12521.      jbsr    _do_bottom_half
  12522.      movew    sp@+,sr
  12523.      subql    #1,_intr_count
  12524. @@ -311,7 +322,7 @@
  12525.  Lnotkernel:
  12526.      addql    #8,sp            | throw away throwaway stack frame
  12527.      oriw    #0x1000,sr        | set master bit in SR (sp is now msp)
  12528. -    andiw    #0xf8ff,sr        | allow interrupts
  12529. +    andiw    #(ALLOWINT),sr        | allow interrupts
  12530.      clrw    sp@-            | stack adjustment
  12531.      subql    #8,sp            | make room for usp and orig_d0
  12532.      movel    d0,sp@-         | save registers as for syscall
  12533. diff -ubr -x RCS -x *.[ao] -x .depend -x .version -x .config -x System.map -x vmlinux -x bootstrap -x *~ -x config.old -x *.orig -x *.rej -x *# -x version.h -x autoconf.h --new-file linux-0.9pl3/m68k/traps.c linux-0.9pl4/m68k/traps.c
  12534. --- linux-0.9pl3/m68k/traps.c    Sun Aug 28 17:16:21 1994
  12535. +++ linux-0.9pl4/m68k/traps.c    Mon Nov 21 18:09:06 1994
  12536. @@ -284,13 +284,13 @@
  12537.      printk ("SSW=%#06x  ", ssw);
  12538.  
  12539.      if (ssw & (FC | FB))
  12540. -        printk ("Instruction fault at %#010x\n",
  12541. +        printk ("Instruction fault at %#010lx\n",
  12542.              ssw & FC ?
  12543.              fp->format == 0xa ? fp->pc + 2 : fp->un.fmtb.baddr - 2
  12544.              :
  12545.              fp->format == 0xa ? fp->pc + 4 : fp->un.fmtb.baddr);
  12546.      if (ssw & DF)
  12547. -        printk ("Data %s fault at %#010x in %s (pc=%#lx)\n",
  12548. +        printk ("Data %s fault at %#010lx in %s (pc=%#lx)\n",
  12549.              ssw & RW ? "read" : "write",
  12550.              fp->un.fmtb.daddr,
  12551.              space_names[ssw & DFC], fp->pc);
  12552. @@ -393,7 +393,7 @@
  12553.             (but only if the page is now valid).  Otherwise we'll get
  12554.             an wierd read access.  */
  12555.      /* XXX can this condition be simplified? */
  12556. -    if (ssw & DF && ssw & RB && mmusr & MMU_I
  12557. +    if (ssw & DF && ssw & RB && (mmusr & MMU_I)
  12558.          && (addr & PAGE_MASK) == (fp->un.fmtb.baddr & PAGE_MASK))
  12559.        {
  12560.          asm volatile ("ptestr #1,%1@,#7\n\t"
  12561. diff -ubr -x RCS -x *.[ao] -x .depend -x .version -x .config -x System.map -x vmlinux -x bootstrap -x *~ -x config.old -x *.orig -x *.rej -x *# -x version.h -x autoconf.h --new-file linux-0.9pl3/mm/memory.c linux-0.9pl4/mm/memory.c
  12562. --- linux-0.9pl3/mm/memory.c    Sun Aug 14 10:29:39 1994
  12563. +++ linux-0.9pl4/mm/memory.c    Mon Nov 21 18:32:45 1994
  12564. @@ -85,7 +85,7 @@
  12565.  
  12566.  /*
  12567.   * oom() prints a message (so that the user knows why the process died),
  12568. - * and gives the process an untrappable SIGSEGV.
  12569. + * and gives the process an untrappable SIGKILL.
  12570.   */
  12571.  void oom(struct task_struct * task)
  12572.  {
  12573. @@ -271,7 +271,9 @@
  12574.          panic("Trying to free up swapper memory space");
  12575.      }
  12576.      root = tsk->tss.pagedir_v;
  12577. -    if (!root || root == task[0]->tss.pagedir_v) {
  12578. +    if (!root)
  12579. +      return;
  12580. +    if (root == task[0]->tss.pagedir_v) {
  12581.          printk("Trying to free kernel root table: not good\n");
  12582.          return;
  12583.      }
  12584. @@ -291,6 +293,8 @@
  12585.       */
  12586.      if (root[NUM_L1_ENTRIES-1] > 0) {
  12587.          root[NUM_L1_ENTRIES-1]--;
  12588. +        tsk->tss.pagedir_v = 0;
  12589. +        tsk->tss.pagedir_p = 0;
  12590.          return;
  12591.      }
  12592.  
  12593. @@ -338,11 +342,11 @@
  12594.  }
  12595.  
  12596.  static int copy_pointer_table (struct task_struct *tsk,
  12597. -                   unsigned long old_ptr_desc,
  12598. +                   unsigned long *old_ptr_table,
  12599.                     unsigned long *new_root)
  12600.  {
  12601.      int i;
  12602. -    unsigned long *old_ptr_table, *new_ptr_table, new_ptr_vaddr;
  12603. +    unsigned long *new_ptr_table, new_ptr_vaddr;
  12604.  
  12605.      /* get a new pointer table, can't allocate, no fork */
  12606.      if (!(new_ptr_table = get_pointer_table ())) {
  12607. @@ -352,13 +356,12 @@
  12608.      new_ptr_vaddr = (unsigned long)new_ptr_table;
  12609.  
  12610.      /* process each page table in the pointer table */
  12611. -    old_ptr_table = (unsigned long *)PTOV(old_ptr_desc & TABLE_MASK);
  12612. -
  12613.      for (i = 0 ; i < NUM_L2_ENTRIES ;
  12614.           i++,old_ptr_table += 16, new_ptr_table += 16) {
  12615.          int j;
  12616.          unsigned long old_pg_table, *old_page_tablep;
  12617.          unsigned long *new_page_tablep;
  12618. +        unsigned long old_pg_table_v;
  12619.  
  12620.          /* read descriptor for page table */
  12621.          old_pg_table = *old_ptr_table;
  12622. @@ -371,7 +374,8 @@
  12623.           * if the address is too high, or it is not a short
  12624.           * descriptor, things are screwy.
  12625.           */
  12626. -        if (PTOV(old_pg_table) >= high_memory
  12627. +        old_pg_table_v = PTOV (old_pg_table & PAGE_MASK);
  12628. +        if (old_pg_table_v >= high_memory
  12629.              || !(old_pg_table & PAGE_TABLE)) {
  12630.              printk("copy_page_tables: bad page table: "
  12631.                     "probable memory corruption\n");
  12632. @@ -383,7 +387,7 @@
  12633.           * if it is a reserved entry (won't be, with the separate kernel
  12634.           * and user virtual address spaces for the M68K port.
  12635.           */
  12636. -        if (mem_map[MAP_NR(PTOV(old_pg_table))] & MAP_PAGE_RESERVED) {
  12637. +        if (mem_map[MAP_NR(old_pg_table_v)] & MAP_PAGE_RESERVED) {
  12638.              *new_ptr_table = old_pg_table;
  12639.              continue;
  12640.          }
  12641. @@ -393,9 +397,9 @@
  12642.              return -ENOMEM;
  12643.  
  12644.          /* process each page in the page table */
  12645. -        old_page_tablep = (unsigned long *)PTOV(old_pg_table & PAGE_MASK);
  12646. +        old_page_tablep = (unsigned long *) old_pg_table_v;
  12647.          for (j = 0 ; j < PTRS_PER_PAGE ; j++,old_page_tablep++,new_page_tablep++) {
  12648. -            unsigned long pg;
  12649. +            unsigned long pg, pg_v;
  12650.  
  12651.              /* read page descriptor from table */
  12652.              pg = *old_page_tablep;
  12653. @@ -417,10 +421,11 @@
  12654.              if ((pg & (PAGE_RONLY | PAGE_COW)) == PAGE_COW)
  12655.                  pg |= PAGE_RONLY;
  12656.              *new_page_tablep = pg;
  12657. -            if (mem_map[MAP_NR(PTOV(pg & PAGE_MASK))] & MAP_PAGE_RESERVED)
  12658. +            pg_v = PTOV (pg & PAGE_MASK);
  12659. +            if (mem_map[MAP_NR(pg_v)] & MAP_PAGE_RESERVED)
  12660.                  continue;
  12661.              *old_page_tablep = pg;
  12662. -            mem_map[MAP_NR(PTOV(pg & PAGE_MASK))]++;
  12663. +            mem_map[MAP_NR(pg_v)]++;
  12664.          }
  12665.      }
  12666.  
  12667. @@ -460,6 +465,7 @@
  12668.  
  12669.      for (i = 0 ; i < NUM_L1_ENTRIES-1 ; i++, old_root++,new_root++) {
  12670.          unsigned long old_ptr_desc;
  12671. +        unsigned long vaddr;
  12672.  
  12673.          /* read descriptor for pointer table */
  12674.          old_ptr_desc = *old_root;
  12675. @@ -472,7 +478,8 @@
  12676.           * if the address is too high, or it is not a short
  12677.           * descriptor, things are screwy.
  12678.           */
  12679. -        if (PTOV(old_ptr_desc) >= high_memory
  12680. +        vaddr = PTOV (old_ptr_desc & TABLE_MASK);
  12681. +        if (vaddr >= high_memory
  12682.              || !(old_ptr_desc & PAGE_TABLE)) {
  12683.              printk("copy_page_tables: bad pointer table: "
  12684.                     "probable memory corruption\n");
  12685. @@ -480,7 +487,7 @@
  12686.              continue;
  12687.          }
  12688.  
  12689. -        if (copy_pointer_table (tsk, old_ptr_desc, new_root))
  12690. +        if (copy_pointer_table (tsk, (unsigned long *)vaddr, new_root))
  12691.              return -ENOMEM;
  12692.      }
  12693.  end:
  12694. @@ -517,10 +524,11 @@
  12695.          if ((page = *page_table) != 0) {
  12696.              *page_table = 0;
  12697.              if (page & PAGE_PRESENT) {
  12698. -                if (!(mem_map[MAP_NR(PTOV(page & PAGE_MASK))] & MAP_PAGE_RESERVED))
  12699. +                unsigned long page_v = PTOV(page & PAGE_MASK);
  12700. +                if (!(mem_map[MAP_NR(page_v)] & MAP_PAGE_RESERVED))
  12701.                                          if (current->rss > 0)
  12702.                                                  --current->rss;
  12703. -                free_page(PTOV(page & PAGE_MASK));
  12704. +                free_page(page_v);
  12705.              } else
  12706.                  swap_free(page);
  12707.          }
  12708. @@ -572,10 +580,11 @@
  12709.          if ((page = *page_table) != 0) {
  12710.              *page_table = 0;
  12711.              if (page & PAGE_PRESENT) {
  12712. -                if (!(mem_map[MAP_NR(PTOV(page & PAGE_MASK))] & MAP_PAGE_RESERVED))
  12713. +                unsigned long page_v = PTOV(page & PAGE_MASK);
  12714. +                if (!(mem_map[MAP_NR(page_v)] & MAP_PAGE_RESERVED))
  12715.                                          if (current->rss > 0)
  12716.                                                  --current->rss;
  12717. -                free_page(PTOV(page & PAGE_MASK));
  12718. +                free_page(page_v);
  12719.              } else
  12720.                  swap_free(page);
  12721.          }
  12722. @@ -636,10 +645,11 @@
  12723.          if ((page = *page_table) != 0) {
  12724.              *page_table = 0;
  12725.              if (page & PAGE_PRESENT) {
  12726. -                if (!(mem_map[MAP_NR(PTOV(page & PAGE_MASK))] & MAP_PAGE_RESERVED))
  12727. +                unsigned long page_v = PTOV(page & PAGE_MASK);
  12728. +                if (!(mem_map[MAP_NR(page_v)] & MAP_PAGE_RESERVED))
  12729.                                          if (current->rss > 0)
  12730.                                                  --current->rss;
  12731. -                free_page(PTOV(page & PAGE_MASK));
  12732. +                free_page(page_v);
  12733.              } else
  12734.                  swap_free(page);
  12735.          }
  12736. @@ -652,7 +662,7 @@
  12737.           */
  12738.          if (!mask)
  12739.              *page_table = 0;    /* not present */
  12740. -        else if (to >= high_memory)
  12741. +        else if (to < KSTART_ADDR || to >= high_memory)
  12742.              *page_table = (VTOP(to) | mask);
  12743.          else if (!mem_map[MAP_NR(to)])
  12744.              *page_table = 0;    /* not present */
  12745. @@ -788,6 +798,7 @@
  12746.  {
  12747.      unsigned long *rootp, desc, *ptep, *ptrp, old_page, prot;
  12748.      unsigned long new_page;
  12749. +    unsigned long vaddr;
  12750.  
  12751.  #ifdef DEBUG
  12752.      if (user_usp)
  12753. @@ -797,27 +808,28 @@
  12754.      new_page = __get_free_page(GFP_KERNEL);
  12755.      rootp = &tsk->tss.pagedir_v[L1_INDEX(address)];
  12756.      desc = *rootp;
  12757. -    if ((desc & PAGE_TABLE) != PAGE_TABLE
  12758. -        || PTOV (desc & TABLE_MASK) >= high_memory)
  12759. +    vaddr = PTOV (desc & TABLE_MASK);
  12760. +    if ((desc & PAGE_TABLE) != PAGE_TABLE || vaddr >= high_memory)
  12761.          panic ("do_wp_page: invalid root table entry %08lx", desc);
  12762. -    ptrp = (unsigned long *)PTOV(desc & TABLE_MASK);
  12763. +    ptrp = (unsigned long *) vaddr;
  12764.      ptrp += L2_INDEX(address);
  12765.      desc = *ptrp;
  12766. -    if ((desc & PAGE_TABLE) != PAGE_TABLE
  12767. -        || PTOV (desc & TABLE_MASK) >= high_memory)
  12768. +    vaddr = PTOV (desc & PAGE_MASK);
  12769. +    if ((desc & PAGE_TABLE) != PAGE_TABLE || vaddr  >= high_memory)
  12770.          goto bad_wp_pagetable;
  12771. -    ptep = (unsigned long *)PTOV(desc & PAGE_MASK) + L3_INDEX(address);
  12772. +    ptep = (unsigned long *) vaddr + L3_INDEX(address);
  12773.      old_page = *ptep;
  12774.      if (!(old_page & PAGE_PRESENT))
  12775.          goto end_wp_page;
  12776. -    if (PTOV (old_page) >= high_memory)
  12777. +    vaddr = PTOV (old_page & PAGE_MASK);
  12778. +    if (vaddr >= high_memory)
  12779.          goto bad_wp_page;
  12780.      if (!(old_page & PAGE_RONLY))
  12781.          goto end_wp_page;
  12782.      /* minor page fault (copy on write) */
  12783.      tsk->min_flt++;
  12784.      prot = ((old_page & ~PAGE_MASK) & ~PAGE_RONLY) | PAGE_RW;
  12785. -    old_page = PTOV(old_page & PAGE_MASK);
  12786. +    old_page = vaddr;
  12787.      /* if page was used only once (no longer shared) enable read write */
  12788.      if (mem_map[MAP_NR(old_page)] != 1) {
  12789.          if (new_page) {
  12790. @@ -868,6 +880,7 @@
  12791.  {
  12792.      unsigned long page, ptrdesc;
  12793.      unsigned long *rootp, *pg_table;
  12794. +    unsigned long vaddr;
  12795.  
  12796.  #ifdef DEBUG
  12797.      printk ("do_wp_page (address=%#lx, user_usp=%#lx\n", address,
  12798. @@ -899,8 +912,9 @@
  12799.           */
  12800.          panic ("do_wp_page: unexplained null pointer table entry for %lx", address);
  12801.      }
  12802. -    if ((page & PAGE_TABLE) && PTOV(page) < high_memory) {
  12803. -        pg_table = (unsigned long *)PTOV(page & PAGE_MASK);
  12804. +    vaddr = PTOV (page & PAGE_MASK);
  12805. +    if ((page & PAGE_TABLE) && vaddr < high_memory) {
  12806. +        pg_table = (unsigned long *) vaddr;
  12807.          pg_table += L3_INDEX(address);
  12808.          page = *pg_table;
  12809.          if (!(page & PAGE_PRESENT))
  12810. @@ -1050,7 +1064,7 @@
  12811.      if (!inode || inode->i_count < 2 || !area->vm_ops)
  12812.          return 0;
  12813.      for (p = &LAST_TASK ; p > &FIRST_TASK ; --p) {
  12814. -        if (!*p)
  12815. +        if (!*p || !(*p)->tss.pagedir_v)
  12816.              continue;
  12817.          if (tsk == *p)
  12818.              continue;
  12819. @@ -1368,6 +1382,11 @@
  12820.              do_no_page (error_code, address, current, user_esp);
  12821.          return;
  12822.      }
  12823. +    if ((fp->un.fmtb.ssw & 4) == 0) {
  12824. +        /* User memory access */
  12825. +        send_sig (SIGSEGV, current, 1);
  12826. +        return;
  12827. +    }
  12828.      printk("Unable to handle kernel paging request at address %08lx from %lx\n",address, fp->pc);
  12829.      die_if_kernel("Oops", fp, error_code);
  12830.      do_exit(SIGKILL);
  12831. @@ -1508,7 +1527,7 @@
  12832.      printk("Free pages:      %6dkB\n",nr_free_pages<<(PAGE_SHIFT-10));
  12833.      printk("Secondary pages: %6dkB\n",nr_secondary_pages<<(PAGE_SHIFT-10));
  12834.      printk("Free swap:       %6dkB\n",nr_swap_pages<<(PAGE_SHIFT-10));
  12835. -    i = (high_memory-0xC0000000) >> PAGE_SHIFT;
  12836. +    i = (high_memory-KSTART_ADDR) >> PAGE_SHIFT;
  12837.      while (i-- > 0) {
  12838.      total++;
  12839.      if (mem_map[i] & MAP_PAGE_RESERVED)
  12840. @@ -1555,6 +1574,69 @@
  12841.              offset += boot_info.memory[i].size;
  12842.      }
  12843.  
  12844. +    /* not in one of the memory chunks; get the actual
  12845. +     * physical address from the MMU.
  12846. +     */
  12847. +    if (boot_info.cputype & CPU_68040) {
  12848. +      unsigned long mmusr;
  12849. +      unsigned short fs = get_fs();
  12850. +
  12851. +      set_fs (SUPER_DATA);
  12852. +
  12853. +      asm volatile ("movel %1,a0\n\t"
  12854. +            ".word 0xf568\n\t"    /* ptestr (a0) */
  12855. +            ".long 0x4e7a8805\n\t"    /* movec mmusr, a0 */
  12856. +            "movel a0,%0"
  12857. +            : "=g" (mmusr)
  12858. +            : "g" (vaddr)
  12859. +            : "a0", "d0");
  12860. +      set_fs (fs);
  12861. +
  12862. +      if (mmusr & MMU_R_040)
  12863. +        return (mmusr & PAGE_MASK) | (vaddr & (PAGE_SIZE-1));
  12864. +
  12865. +      panic ("VTOP040: bad virtual address %08lx (%lx)", vaddr, mmusr);
  12866. +    } else {
  12867. +      volatile unsigned short temp;
  12868. +      unsigned short mmusr;
  12869. +      unsigned long *descaddr;
  12870. +
  12871. +      asm volatile ("ptestr #5,%2@,#7,%0\n\t"
  12872. +            "pmove psr,%1@"
  12873. +            : "=a&" (descaddr)
  12874. +            : "a" (&temp), "a" (vaddr));
  12875. +      mmusr = temp;
  12876. +
  12877. +      printk ("mmusr is %#x for kernel vaddr %#lx\n",
  12878. +          mmusr, vaddr);
  12879. +
  12880. +      if (mmusr & (MMU_I|MMU_B|MMU_L))
  12881. +        panic ("VTOP030: bad virtual address %08lx (%x)", vaddr, mmusr);
  12882. +
  12883. +      descaddr = (unsigned long *)PTOV(descaddr);
  12884. +
  12885. +      printk ("descriptor address is %p, contents %#lx\n",
  12886. +          descaddr, *descaddr);
  12887. +
  12888. +      switch (mmusr & MMU_NUM) {
  12889. +      case 1:
  12890. +        printk ("physaddr for %lx is %lx\n", vaddr,
  12891. +            (*descaddr & 0xfe000000) | (vaddr & 0x01ffffff));
  12892. +        return (*descaddr & 0xfe000000) | (vaddr & 0x01ffffff);
  12893. +      case 2:
  12894. +        printk ("physaddr for %lx is %lx\n", vaddr,
  12895. +            (*descaddr & 0xfffc0000) | (vaddr & 0x0003ffff));
  12896. +        return (*descaddr & PAGE_MASK) | (vaddr & 0x0003ffff);
  12897. +      case 3:
  12898. +        printk ("physaddr for %lx is %lx\n", vaddr,
  12899. +            (*descaddr & PAGE_MASK) | (vaddr & (PAGE_SIZE-1)));
  12900. +        return (*descaddr & PAGE_MASK) | (vaddr & (PAGE_SIZE-1));
  12901. +      default:
  12902. +        panic ("VTOP: bad levels (%d) for virtual address %08lx", 
  12903. +           mmusr & MMU_NUM, vaddr);
  12904. +      }
  12905. +    }
  12906. +
  12907.      panic ("VTOP: bad virtual address %08lx", vaddr);
  12908.  }
  12909.  
  12910. @@ -1577,8 +1659,21 @@
  12911.              offset += boot_info.memory[i].size;
  12912.      }
  12913.  
  12914. -    panic ("PTOV: bad physical address %08lx (called from %p)\n",
  12915. -           paddr, __builtin_return_address(0));
  12916. +    /*
  12917. +     * assume that the kernel virtual address is the same as the
  12918. +     * physical address.
  12919. +     *
  12920. +     * This should be reasonable in most situations:
  12921. +     *  1) They shouldn't be dereferencing the virtual address
  12922. +     *     unless they are sure that it is valid from kernel space.
  12923. +     *  2) The only usage I see so far is converting a page table
  12924. +     *     reference to some non-FASTMEM address space when freeing
  12925. +         *     mmaped "/dev/mem" pages.  These addresses are just passed
  12926. +     *     to "free_page", which ignores addresses that aren't in
  12927. +     *     the memory list anyway.
  12928. +     *
  12929. +     */
  12930. +    return paddr;
  12931.  }
  12932.  
  12933.  static unsigned long *kernel_pointer_table (void)
  12934. @@ -1968,7 +2063,7 @@
  12935.      virtual_start = availmem;
  12936.  
  12937.      /* virtual address of end of available memory */
  12938. -    virtual_end = (unsigned long)start + mem_avail;
  12939. +    virtual_end = KSTART_ADDR + mem_avail;
  12940.  
  12941.  #ifdef DEBUG
  12942.      printk ("virtual_start is %#lx\nvirtual_end is %#lx\n",
  12943. @@ -2060,6 +2155,37 @@
  12944.          start_mem += PAGE_SIZE;
  12945.      }
  12946.  
  12947. +#ifdef CONFIG_ATARI
  12948. +
  12949. +    if (boot_info.machtype == MACH_ATARI) {
  12950. +
  12951. +        /* If the page with physical address 0 isn't the first kernel
  12952. +         * code page, it has to be reserved because the first 2 KB of
  12953. +         * ST-Ram can only be accessed from supervisor mode by
  12954. +         * hardware.
  12955. +         */
  12956. +
  12957. +        unsigned long virt0 = PTOV( 0 ), adr;
  12958. +        extern unsigned long rsvd_stram_beg, rsvd_stram_end;
  12959. +        
  12960. +        if (virt0 != KSTART_ADDR) {
  12961. +
  12962. +            mem_map[MAP_NR(virt0)] = MAP_PAGE_RESERVED;
  12963. +
  12964. +            /* Also, reserve all pages that have been marked by
  12965. +             * stram_alloc() (e.g. for the screen memory). (This may
  12966. +             * treat the first ST-Ram page a second time, but that
  12967. +             * doesn't hurt...) */
  12968. +            
  12969. +            rsvd_stram_end += PAGE_SIZE - 1;
  12970. +            rsvd_stram_end &= PAGE_MASK;
  12971. +            rsvd_stram_beg &= PAGE_MASK;
  12972. +            for( adr = rsvd_stram_beg; adr < rsvd_stram_end; adr += PAGE_SIZE )
  12973. +                mem_map[MAP_NR(adr)] = MAP_PAGE_RESERVED;
  12974. +        }
  12975. +    }
  12976. +    
  12977. +#endif
  12978.  #ifdef DEBUG
  12979.      printk ("task[0] root table is %p\n", task[0]->tss.pagedir_v);
  12980.  #endif
  12981. diff -ubr -x RCS -x *.[ao] -x .depend -x .version -x .config -x System.map -x vmlinux -x bootstrap -x *~ -x config.old -x *.orig -x *.rej -x *# -x version.h -x autoconf.h --new-file linux-0.9pl3/mm/mmap.c linux-0.9pl4/mm/mmap.c
  12982. --- linux-0.9pl3/mm/mmap.c    Sun Aug 14 10:29:39 1994
  12983. +++ linux-0.9pl4/mm/mmap.c    Thu Nov 24 21:10:20 1994
  12984. @@ -48,6 +48,9 @@
  12985.  {
  12986.      int mask, error;
  12987.      
  12988. +    if ((len = PAGE_ALIGN(len)) == 0)
  12989. +        return addr;
  12990. +
  12991.      if (addr > TASK_SIZE || len > TASK_SIZE || addr > TASK_SIZE-len)
  12992.          return -EINVAL;
  12993.      
  12994. @@ -110,13 +113,15 @@
  12995.      if (file && (!file->f_op || !file->f_op->mmap))
  12996.          return -ENODEV;
  12997.      mask = 0;
  12998. -    if (prot & (PROT_READ | PROT_EXEC))
  12999. +    if (!(prot & PROT_WRITE))
  13000.          mask |= PAGE_READONLY;
  13001. -    if (prot & PROT_WRITE)
  13002. +    if (prot & PROT_WRITE) {
  13003. +        mask &= ~PAGE_READONLY;
  13004.          if ((flags & MAP_TYPE) == MAP_PRIVATE)
  13005.              mask |= PAGE_COPY;
  13006.          else
  13007.              mask |= PAGE_SHARED;
  13008. +    }
  13009.      if (!mask)
  13010.          return -EINVAL;
  13011.  
  13012. diff -ubr -x RCS -x *.[ao] -x .depend -x .version -x .config -x System.map -x vmlinux -x bootstrap -x *~ -x config.old -x *.orig -x *.rej -x *# -x version.h -x autoconf.h --new-file linux-0.9pl3/mm/swap.c linux-0.9pl4/mm/swap.c
  13013. --- linux-0.9pl3/mm/swap.c    Mon Sep 19 22:00:57 1994
  13014. +++ linux-0.9pl4/mm/swap.c    Mon Oct 10 16:48:32 1994
  13015. @@ -321,7 +321,6 @@
  13016.      int counter = NR_TASKS * 2 >> priority;
  13017.      struct task_struct *p;
  13018.  
  13019. -    counter = NR_TASKS * 2 >> priority;
  13020.      for(; counter >= 0; counter--, swap_task++) {
  13021.      /*
  13022.       * Check that swap_task is suitable for swapping.  If not, look for
  13023. @@ -366,30 +365,36 @@
  13024.      /* On the m68k, the last entry in the root table is the use
  13025.         count, it must not be touched */
  13026.      for(table = p->swap_table; table < 1024 - 8; table++) {
  13027. -        unsigned long desc, *ptr;
  13028. +        unsigned long desc, desc_p, *ptr;
  13029. +        unsigned long pg_table_p;
  13030.  
  13031. -        desc = L1_SWAP_INDEX(p->tss.pagedir_v,table);
  13032. -        if(!desc || PTOV(desc & TABLE_MASK) >= high_memory)
  13033. +        desc_p = L1_SWAP_INDEX(p->tss.pagedir_v,table);
  13034. +        if (!desc_p)
  13035.              continue;
  13036. -        if(!(PAGE_TABLE & desc)) {
  13037. +        desc = PTOV (desc_p & TABLE_MASK);
  13038. +        if (desc >= high_memory)
  13039. +            continue;
  13040. +        if (!(PAGE_TABLE & desc_p)) {
  13041.              printk("swap_out: bad page-table at pg_dir[%d]: %08lx\n",
  13042. -                table, desc);
  13043. +                table, desc_p);
  13044.              L1_SWAP_INDEX(p->tss.pagedir_v,table) = 0;
  13045.              continue;
  13046.          }
  13047. -        ptr = (unsigned long *)PTOV(desc & TABLE_MASK);
  13048. -        pg_table = L2_SWAP_INDEX(ptr,table);
  13049. -        if (!pg_table || PTOV(pg_table & PAGE_MASK) >= high_memory)
  13050. +        ptr = (unsigned long *) desc;
  13051. +        pg_table_p = L2_SWAP_INDEX(ptr,table);
  13052. +        if (!pg_table_p)
  13053.              continue;
  13054. -        if(mem_map[MAP_NR(PTOV(pg_table & PAGE_MASK))] & MAP_PAGE_RESERVED)
  13055. +        pg_table = PTOV (pg_table_p & PAGE_MASK);
  13056. +        if (pg_table >= high_memory)
  13057.              continue;
  13058. -        if(!(PAGE_TABLE & pg_table)) {
  13059. +        if (mem_map[MAP_NR(pg_table)] & MAP_PAGE_RESERVED)
  13060. +            continue;
  13061. +        if (!(PAGE_TABLE & pg_table_p)) {
  13062.              printk("swap_out: bad page-table at pg_dir[%d]: %08lx\n",
  13063. -                table, pg_table);
  13064. +                table, pg_table_p);
  13065.              L2_SWAP_INDEX(ptr,table) = 0;
  13066.              continue;
  13067.          }
  13068. -        pg_table = PTOV(pg_table & PAGE_MASK);
  13069.  
  13070.          /*
  13071.           * Go through this page table.
  13072. @@ -661,8 +666,8 @@
  13073.      if (intr_count && priority != GFP_ATOMIC) {
  13074.          static int count = 0;
  13075.          if (++count < 5) {
  13076. -            printk("gfp called nonatomically from interrupt %08lx\n",
  13077. -                ((unsigned long *)&priority)[-1]);
  13078. +            printk("gfp called nonatomically from interrupt %p\n",
  13079. +                __builtin_return_address (0));
  13080.              priority = GFP_ATOMIC;
  13081.          }
  13082.      }
  13083. @@ -703,19 +708,21 @@
  13084.              continue;
  13085.          for (pgt = 0 ; pgt < PTRS_PER_PAGE ; pgt++) {
  13086.              desc = L1_SWAP_INDEX(p->tss.pagedir_v,pgt);
  13087. -            if (!desc)
  13088. +            if (!desc || !(desc & PAGE_TABLE))
  13089.                  continue;
  13090. -            if (!(desc & PAGE_TABLE) || PTOV(desc & TABLE_MASK) >= high_memory)
  13091. +            desc = PTOV (desc & TABLE_MASK);
  13092. +            if (desc >= high_memory)
  13093.                  continue;
  13094. -            ptr = (unsigned long *)PTOV(desc & TABLE_MASK);
  13095. +            ptr = (unsigned long *) desc;
  13096.              page = L2_SWAP_INDEX(ptr,pgt);
  13097. -            if (!page)
  13098. +            if (!page || !(page & PAGE_TABLE))
  13099.                  continue;
  13100. -            if (!(page & PAGE_PRESENT) || (PTOV(page & PAGE_MASK) >= high_memory))
  13101. +            page = PTOV (page & PAGE_MASK);
  13102. +            if (page >= high_memory)
  13103.                  continue;
  13104. -            if (mem_map[MAP_NR(PTOV(page & PAGE_MASK))] & MAP_PAGE_RESERVED)
  13105. +            if (mem_map[MAP_NR(page)] & MAP_PAGE_RESERVED)
  13106.                  continue;
  13107. -            ppage = (unsigned long *) PTOV(page & PAGE_MASK);
  13108. +            ppage = (unsigned long *) page;
  13109.              for (pg = 0 ; pg < PTRS_PER_PAGE ; pg++,ppage++) {
  13110.                  page = *ppage;
  13111.                  if (!page)
  13112. diff -ubr -x RCS -x *.[ao] -x .depend -x .version -x .config -x System.map -x vmlinux -x bootstrap -x *~ -x config.old -x *.orig -x *.rej -x *# -x version.h -x autoconf.h --new-file linux-0.9pl3/mm/vmalloc.c linux-0.9pl4/mm/vmalloc.c
  13113. --- linux-0.9pl3/mm/vmalloc.c    Sun Aug 14 10:29:39 1994
  13114. +++ linux-0.9pl4/mm/vmalloc.c    Sat Nov  5 13:08:33 1994
  13115. @@ -137,8 +137,8 @@
  13116.      if (!(PAGE_TABLE & (ptr = krt[dindex >> 3])))
  13117.          return 0;
  13118.      ptrp = (unsigned long *)PTOV(ptr & TABLE_MASK);
  13119. -    ptrp += (16*sizeof(long))*(dindex & (NUM_L2_ENTRIES-1));
  13120. -    if (!(PAGE_TABLE & (page = ptrp[16*(dindex & (NUM_L2_ENTRIES-1))])))
  13121. +    ptrp += 16*(dindex & (NUM_L2_ENTRIES-1));
  13122. +    if (!(PAGE_TABLE & (page = *ptrp)))
  13123.          return 0;
  13124.      page = PTOV(page & PAGE_MASK);
  13125.      pte = index + (unsigned long *) page;
  13126. @@ -154,7 +154,7 @@
  13127.          if (*pte)
  13128.              return 0;
  13129.      mem_map[MAP_NR(page)] &= ~MAP_PAGE_RESERVED;
  13130. -    free_page_table(&ptrp[16*(dindex & (NUM_L2_ENTRIES-1))]);
  13131. +    free_page_table(ptrp);
  13132.      return 0;
  13133.  }
  13134.  
  13135. @@ -175,9 +175,10 @@
  13136.              krt[dindex >> 3] = VTOP(ptrp) | PAGE_TABLE;
  13137.      } else
  13138.          ptrp = (unsigned long *)PTOV(ptr & TABLE_MASK);
  13139. -    page = ptrp[16*(dindex & (NUM_L2_ENTRIES-1))];
  13140. +    ptrp += 16*(dindex & (NUM_L2_ENTRIES-1));
  13141. +    page = *ptrp;
  13142.      if (!page) {
  13143. -        page = (unsigned long)get_page_table (&ptrp[16*(dindex & (NUM_L2_ENTRIES-1))]);
  13144. +        page = (unsigned long)get_page_table (ptrp);
  13145.          if (!page)
  13146.              return -ENOMEM;
  13147.          else
  13148. @@ -240,7 +241,8 @@
  13149.      for (p = &vmlist ; (tmp = *p) ; p = &tmp->next) {
  13150.          if (tmp->addr == addr) {
  13151.              *p = tmp->next;
  13152. -            do_area(tmp->addr, tmp->size, free_area_pages);
  13153. +            do_area(tmp->addr, tmp->size - PAGE_SIZE,
  13154. +                free_area_pages);
  13155.              kfree(tmp);
  13156.              return;
  13157.          }
  13158. diff -ubr -x RCS -x *.[ao] -x .depend -x .version -x .config -x System.map -x vmlinux -x bootstrap -x *~ -x config.old -x *.orig -x *.rej -x *# -x version.h -x autoconf.h --new-file linux-0.9pl3/net/inet/dev.c linux-0.9pl4/net/inet/dev.c
  13159. --- linux-0.9pl3/net/inet/dev.c    Tue Sep 27 20:50:20 1994
  13160. +++ linux-0.9pl4/net/inet/dev.c    Mon Oct 10 16:48:34 1994
  13161. @@ -134,6 +134,7 @@
  13162.  
  13163.  struct packet_type *ptype_base = &ip_packet_type;
  13164.  static struct sk_buff *volatile backlog = NULL;
  13165. +static int backlog_size = 0;
  13166.  static unsigned long ip_bcast = 0;
  13167.  
  13168.  
  13169. @@ -482,13 +483,24 @@
  13170.  void
  13171.  netif_rx(struct sk_buff *skb)
  13172.  {
  13173. +  static int dropping = 0;
  13174.    /* Set any necessary flags. */
  13175.    skb->sk = NULL;
  13176.    skb->free = 1;
  13177.    
  13178. +  /* check that we aren't oevrdoing things.. */
  13179. +  if (!backlog_size)
  13180. +      dropping = 0;
  13181. +  else if (backlog_size > 100)
  13182. +      dropping = 1;
  13183. +  if (dropping) {
  13184. +    kfree_skb(skb, FREE_READ);
  13185. +    return;
  13186. +  }
  13187.    /* and add it to the "backlog" queue. */
  13188.    IS_SKB(skb);
  13189.    skb_queue_tail(&backlog,skb);
  13190. +  backlog_size++;
  13191.     
  13192.    /* If any packet arrived, mark it for processing. */
  13193.    if (backlog != NULL) mark_bh(INET_BH);
  13194. @@ -607,6 +619,7 @@
  13195.    /* Any data left to process? */
  13196.    while((skb=skb_dequeue(&backlog))!=NULL)
  13197.    {
  13198. +      backlog_size--;
  13199.        nitcount=dev_nit;
  13200.      flag=0;
  13201.      sti();
  13202. @@ -637,9 +650,6 @@
  13203.       * to anyone who wants it.
  13204.       */
  13205.      for (ptype = ptype_base; ptype != NULL; ptype = ptype->next) {
  13206. -        DPRINTF((DBG_DEV,
  13207. -            "INET: type is %x, comparing to %x\n", type,
  13208. -             ptype->type));
  13209.          if (ptype->type == type || ptype->type == NET16(ETH_P_ALL)) {
  13210.              struct sk_buff *skb2;
  13211.  
  13212. @@ -735,6 +745,9 @@
  13213.    memcpy_fromfs(&ifc, arg, sizeof(struct ifconf));
  13214.    len = ifc.ifc_len;
  13215.    pos = ifc.ifc_buf;
  13216. +  err=verify_area(VERIFY_WRITE, pos, len);
  13217. +  if(err)
  13218. +    return err;
  13219.  
  13220.    /* Loop over the interfaces, and write an info block for each. */
  13221.    for (dev = dev_base; dev != NULL; dev = dev->next) {
  13222. diff -ubr -x RCS -x *.[ao] -x .depend -x .version -x .config -x System.map -x vmlinux -x bootstrap -x *~ -x config.old -x *.orig -x *.rej -x *# -x version.h -x autoconf.h --new-file linux-0.9pl3/net/inet/eth.c linux-0.9pl4/net/inet/eth.c
  13223. --- linux-0.9pl3/net/inet/eth.c    Tue Sep 27 20:51:24 1994
  13224. +++ linux-0.9pl4/net/inet/eth.c    Mon Oct 10 16:48:34 1994
  13225. @@ -106,7 +106,6 @@
  13226.    /* Fill in the basic Ethernet MAC header. */
  13227.    eth = (struct ethhdr *) buff;
  13228.    eth->h_proto = htons(type);
  13229. -  DPRINTF((DBG_DEV, "ETH: eth->h_proto = %x)\n", eth->h_proto));
  13230.  
  13231.    /* We don't ARP for the LOOPBACK device... */
  13232.    if (dev->flags & IFF_LOOPBACK) {
  13233. diff -ubr -x RCS -x *.[ao] -x .depend -x .version -x .config -x System.map -x vmlinux -x bootstrap -x *~ -x config.old -x *.orig -x *.rej -x *# -x version.h -x autoconf.h --new-file linux-0.9pl3/net/inet/icmp.c linux-0.9pl4/net/inet/icmp.c
  13234. --- linux-0.9pl3/net/inet/icmp.c    Tue Mar  1 11:51:41 1994
  13235. +++ linux-0.9pl4/net/inet/icmp.c    Mon Oct 10 16:48:35 1994
  13236. @@ -285,6 +285,65 @@
  13237.  }
  13238.  
  13239.  
  13240. +/* Handle ICMP Timestamp requests. */
  13241. +static void
  13242. +icmp_timestamp(struct icmphdr *icmph, struct sk_buff *skb, struct device *dev,
  13243. +      unsigned long saddr, unsigned long daddr, int len,
  13244. +      struct options *opt)
  13245. +{
  13246. +  struct icmphdr *icmphr;
  13247. +  struct sk_buff *skb2;
  13248. +  int size, offset;
  13249. +  unsigned long *timeptr, midtime;
  13250. +  extern struct timeval xtime;            /* kernel/time.c */
  13251. +
  13252. +  size = sizeof(struct sk_buff) + dev->hard_header_len + 64 + len;
  13253. +  if (! (skb2 = alloc_skb(size, GFP_ATOMIC))) {
  13254. +    skb->sk = NULL;
  13255. +    kfree_skb(skb, FREE_READ);
  13256. +    return;
  13257. +  }
  13258. +  skb2->sk = NULL;
  13259. +  skb2->mem_addr = skb2;
  13260. +  skb2->mem_len = size;
  13261. +  skb2->free = 1;
  13262. +
  13263. +  /* Build Layer 2-3 headers for message back to source */
  13264. +  offset = ip_build_header(skb2, daddr, saddr, &dev, IPPROTO_ICMP, opt, len, 
  13265. +                skb->ip_hdr->tos, 255);
  13266. +  if (offset < 0) {
  13267. +    printk("ICMP: Could not build IP Header for ICMP TIMESTAMP Response\n");
  13268. +    kfree_skb(skb2, FREE_WRITE);
  13269. +    skb->sk = NULL;
  13270. +    kfree_skb(skb, FREE_READ);
  13271. +    return;
  13272. +  }
  13273. +
  13274. +  /* Re-adjust length according to actual IP header size. */
  13275. +  skb2->len = offset + len;
  13276. +
  13277. +  /* Build ICMP_TIMESTAMP Response message. */
  13278. +  icmphr = (struct icmphdr *) ((char *) (skb2 + 1) + offset);
  13279. +  memcpy((char *) icmphr, (char *) icmph, len);
  13280. +  icmphr->type = ICMP_TIMESTAMPREPLY;
  13281. +  icmphr->code = icmphr->checksum = 0;
  13282. +
  13283. +  /* fill in the current time as ms since midnight UT: */
  13284. +  midtime = (xtime.tv_sec % 86400) * 1000 + xtime.tv_usec / 1000;
  13285. +  timeptr = (unsigned long *) (icmphr + 1);
  13286. +  /* the originate timestamp (timeptr [0]) is still in the copy: */
  13287. +  timeptr [1] = timeptr [2] = htonl(midtime);
  13288. +
  13289. +  icmphr->checksum = ip_compute_csum((unsigned char *) icmphr, len);
  13290. +
  13291. +  /* Ship it out - free it when done */
  13292. +  ip_queue_xmit((struct sock *) NULL, dev, skb2, 1);
  13293. +
  13294. +  skb->sk = NULL;
  13295. +  kfree_skb(skb, FREE_READ);
  13296. +}
  13297. +
  13298. +
  13299.  /* Handle the ICMP INFORMATION REQUEST. */
  13300.  static void
  13301.  icmp_info(struct icmphdr *icmph, struct sk_buff *skb, struct device *dev,
  13302. @@ -397,6 +456,13 @@
  13303.          icmp_echo(icmph, skb1, dev, saddr, daddr, len, opt);
  13304.          return 0;
  13305.      case ICMP_ECHOREPLY:
  13306. +        skb1->sk = NULL;
  13307. +        kfree_skb(skb1, FREE_READ);
  13308. +        return(0);
  13309. +    case ICMP_TIMESTAMP:
  13310. +        icmp_timestamp(icmph, skb1, dev, saddr, daddr, len, opt);
  13311. +        return 0;
  13312. +    case ICMP_TIMESTAMPREPLY:
  13313.          skb1->sk = NULL;
  13314.          kfree_skb(skb1, FREE_READ);
  13315.          return(0);
  13316. diff -ubr -x RCS -x *.[ao] -x .depend -x .version -x .config -x System.map -x vmlinux -x bootstrap -x *~ -x config.old -x *.orig -x *.rej -x *# -x version.h -x autoconf.h --new-file linux-0.9pl3/net/inet/ip.c linux-0.9pl4/net/inet/ip.c
  13317. --- linux-0.9pl3/net/inet/ip.c    Mon Sep 26 19:24:28 1994
  13318. +++ linux-0.9pl4/net/inet/ip.c    Mon Oct 10 16:48:38 1994
  13319. @@ -10,6 +10,7 @@
  13320.   * Authors:    Ross Biro, <bir7@leland.Stanford.Edu>
  13321.   *        Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
  13322.   *        Donald Becker, <becker@super.org>
  13323. + *        Alan Cox, <gw4pts@gw4pts.ampr.org>
  13324.   *
  13325.   * Fixes:
  13326.   *        Alan Cox    :    Commented a couple of minor bits of surplus code
  13327. @@ -40,6 +41,9 @@
  13328.   *        Alan Cox    :    Silly ip bug when an overlength
  13329.   *                    fragment turns up. Now frees the
  13330.   *                    queue.
  13331. + *        Linus Torvalds/ :    Memory leakage on fragmentation    
  13332. + *        Alan Cox    :    handling.
  13333. + *        Gerhard Koerting:    Forwarding uses IP priority hints
  13334.   *
  13335.   * To Fix:
  13336.   *        IP option processing is mostly not needed. ip_forward needs to know about routing rules
  13337. @@ -238,7 +242,7 @@
  13338.          return(-ENETUNREACH);
  13339.  
  13340.      *dev = rt->rt_dev;
  13341. -    if (saddr == 0x0100007FL && daddr != 0x0100007FL) 
  13342. +    if (saddr == htonl (0x7F000001L) && daddr != htonl (0x7F000001L)) 
  13343.          saddr = rt->rt_dev->pa_addr;
  13344.      raddr = rt->rt_gateway;
  13345.  
  13346. @@ -891,8 +895,7 @@
  13347.         offset = ntohs(iph->frag_off);
  13348.         flags = offset & ~IP_OFFSET;
  13349.         offset &= IP_OFFSET;
  13350. -       if (((flags & IP_MF) == 0) && (offset == 0)) 
  13351. -       {
  13352. +       if (((flags & IP_MF) == 0) && (offset == 0)) {
  13353.           if (qp != NULL) 
  13354.               ip_free(qp);    /* Huh? How could this exist?? */
  13355.           return(skb);
  13356. @@ -904,18 +907,18 @@
  13357.          * as we still are receiving fragments.  Otherwise, create a fresh
  13358.           * queue entry.
  13359.           */
  13360. -       if (qp != NULL) 
  13361. -       {
  13362. +    if (qp != NULL) {
  13363.           del_timer(&qp->timer);
  13364.           qp->timer.expires = IP_FRAG_TIME;    /* about 30 seconds    */
  13365.           qp->timer.data = (unsigned long) qp;    /* pointer to queue    */
  13366.           qp->timer.function = ip_expire;        /* expire function    */
  13367.           add_timer(&qp->timer);
  13368. +    } else {
  13369. +        if ((qp = ip_create(skb, iph, dev)) == NULL) {
  13370. +            skb->sk = NULL;
  13371. +            kfree_skb(skb, FREE_READ);
  13372. +            return NULL;
  13373.         } 
  13374. -       else 
  13375. -       {
  13376. -         if ((qp = ip_create(skb, iph, dev)) == NULL) 
  13377. -             return(NULL);
  13378.         }
  13379.   
  13380.         /* Determine the position of this fragment. */
  13381. @@ -984,6 +987,7 @@
  13382.               if (tfp->next != NULL) 
  13383.                   next->next->prev = next->prev;
  13384.               
  13385. +             kfree_skb(next->skb, FREE_READ);
  13386.               kfree_s(next, sizeof(struct ipfrag));
  13387.           }
  13388.           DPRINTF((DBG_IP, "IP: defrag: fixed high overlap %d bytes\n", i));
  13389. @@ -992,6 +996,11 @@
  13390.         /* Insert this fragment in the chain of fragments. */
  13391.         tfp = NULL;
  13392.         tfp = ip_frag_create(offset, end, skb, ptr);
  13393. +       if (!tfp) {
  13394. +           skb->sk = NULL;
  13395. +           kfree_skb(skb, FREE_READ);
  13396. +           return NULL;
  13397. +       }
  13398.         tfp->prev = prev;
  13399.         tfp->next = next;
  13400.         if (prev != NULL) 
  13401. @@ -1052,6 +1061,8 @@
  13402.           dev->name, dev->mtu, left, in_ntoa(iph->saddr)));
  13403.         DPRINTF((DBG_IP, " DST=%s\n", in_ntoa(iph->daddr)));
  13404.   
  13405. +    if (mtu < 8)
  13406. +        return;
  13407.         /* Check for any "DF" flag. */
  13408.         if (iph->frag_off & htons (IP_DF)) 
  13409.         {
  13410. @@ -1060,11 +1071,6 @@
  13411.               dev->name, dev->mtu, left, in_ntoa(iph->saddr)));
  13412.           DPRINTF((DBG_IP, " DST=%s\n", in_ntoa(iph->daddr)));
  13413.   
  13414. -         /*
  13415. -          * FIXME:
  13416. -          * We should send an ICMP warning message here!
  13417. -          */
  13418. -          
  13419.           icmp_send(skb,ICMP_DEST_UNREACH, ICMP_FRAG_NEEDED, dev); 
  13420.           return;
  13421.         }
  13422. @@ -1077,15 +1083,6 @@
  13423.         while(left > 0) 
  13424.         {
  13425.           len = left;
  13426. -#ifdef OLD         
  13427. -         if (len+8 > mtu) 
  13428. -             len = (dev->mtu - hlen - 8);
  13429. -         if ((left - len) >= 8) 
  13430. -         {
  13431. -             len /= 8;
  13432. -             len *= 8;
  13433. -         }
  13434. -#else
  13435.          /* IF: it doesn't fit, use 'mtu' - the data space left */
  13436.          if (len > mtu)
  13437.              len = mtu;
  13438. @@ -1096,7 +1093,6 @@
  13439.              len/=8;
  13440.              len*=8;
  13441.          }
  13442. -#endif                 
  13443.           DPRINTF((DBG_IP,"IP: frag: creating fragment of %d bytes (%d total)\n",
  13444.                               len, len + hlen));
  13445.   
  13446. @@ -1259,7 +1255,14 @@
  13447.          kfree_skb(skb2,FREE_WRITE);
  13448.      }
  13449.      else
  13450. +    {
  13451. +        if(iph->tos & IPTOS_LOWDELAY)
  13452. +            dev2->queue_xmit(skb2, dev2, SOPRI_INTERACTIVE);
  13453. +        else if(iph->tos & IPTOS_THROUGHPUT)
  13454. +            dev2->queue_xmit(skb2, dev2, SOPRI_BACKGROUND);
  13455. +        else
  13456.          dev2->queue_xmit(skb2, dev2, SOPRI_NORMAL);
  13457. +    }
  13458.    }
  13459.  }
  13460.  
  13461. diff -ubr -x RCS -x *.[ao] -x .depend -x .version -x .config -x System.map -x vmlinux -x bootstrap -x *~ -x config.old -x *.orig -x *.rej -x *# -x version.h -x autoconf.h --new-file linux-0.9pl3/net/inet/skbuff.c linux-0.9pl4/net/inet/skbuff.c
  13462. --- linux-0.9pl3/net/inet/skbuff.c    Thu Mar 10 14:15:09 1994
  13463. +++ linux-0.9pl4/net/inet/skbuff.c    Mon Oct 10 16:48:38 1994
  13464. @@ -426,12 +426,14 @@
  13465.  struct sk_buff *alloc_skb(unsigned int size,int priority)
  13466.  {
  13467.      struct sk_buff *skb;
  13468. -    extern unsigned long intr_count;
  13469.  
  13470.      if (intr_count && priority != GFP_ATOMIC) {
  13471. +        static int count = 0;
  13472. +        if (++count < 5) {
  13473.          printk("alloc_skb called nonatomically from interrupt %08lx\n",
  13474.              ((unsigned long *)&size)[-1]);
  13475.          priority = GFP_ATOMIC;
  13476. +        }
  13477.      }
  13478.      skb=(struct sk_buff *)kmalloc(size,priority);
  13479.      if(skb==NULL)
  13480. diff -ubr -x RCS -x *.[ao] -x .depend -x .version -x .config -x System.map -x vmlinux -x bootstrap -x *~ -x config.old -x *.orig -x *.rej -x *# -x version.h -x autoconf.h --new-file linux-0.9pl3/net/inet/sock.c linux-0.9pl4/net/inet/sock.c
  13481. --- linux-0.9pl3/net/inet/sock.c    Mon Sep 26 19:24:30 1994
  13482. +++ linux-0.9pl4/net/inet/sock.c    Mon Oct 10 16:48:40 1994
  13483. @@ -428,7 +428,7 @@
  13484.     * structure, otherwise we need to keep it around until
  13485.     * everything is gone.
  13486.     */
  13487. -      if (sk->rmem_alloc == 0 && sk->wmem_alloc == 0) 
  13488. +      if (sk->dead && sk->rmem_alloc == 0 && sk->wmem_alloc == 0) 
  13489.        {
  13490.          kfree_s((void *)sk,sizeof(*sk));
  13491.        } 
  13492. @@ -1194,8 +1194,12 @@
  13493.     * We need to free it up because the tcp module creates
  13494.     * it's own when it accepts one.
  13495.     */
  13496. -  if (newsock->data) kfree_s(newsock->data, sizeof(struct sock));
  13497. +  if (newsock->data) {
  13498. +      struct sock * sk = (struct sock *) newsock->data;
  13499.    newsock->data = NULL;
  13500. +      sk->dead = 1;
  13501. +      destroy_sock(sk);
  13502. +  }
  13503.  
  13504.    if (sk1->prot->accept == NULL) return(-EOPNOTSUPP);
  13505.  
  13506. diff -ubr -x RCS -x *.[ao] -x .depend -x .version -x .config -x System.map -x vmlinux -x bootstrap -x *~ -x config.old -x *.orig -x *.rej -x *# -x version.h -x autoconf.h --new-file linux-0.9pl3/net/inet/tcp.c linux-0.9pl4/net/inet/tcp.c
  13507. --- linux-0.9pl3/net/inet/tcp.c    Mon Sep 26 19:24:33 1994
  13508. +++ linux-0.9pl4/net/inet/tcp.c    Mon Oct 10 16:48:43 1994
  13509. @@ -12,6 +12,9 @@
  13510.   *        Mark Evans, <evansmp@uhura.aston.ac.uk>
  13511.   *        Corey Minyard <wf-rch!minyard@relay.EU.net>
  13512.   *        Florian La Roche, <flla@stud.uni-sb.de>
  13513. + *        Charles Hedrick, <hedrick@klinzhai.rutgers.edu>
  13514. + *        Linus Torvalds, <torvalds@cs.helsinki.fi>
  13515. + *        Alan Cox, <gw4pts@gw4pts.ampr.org>
  13516.   *
  13517.   * Fixes:    
  13518.   *        Alan Cox    :    Numerous verify_area() calls
  13519. @@ -63,6 +66,7 @@
  13520.   *        Charles Hedrick    :    Window fix
  13521.   *        Linus        :    Rewrote tcp_read() and URG handling
  13522.   *                    completely
  13523. + *        Gerhard Koerting:    Fixed some missing timer handling
  13524.   *
  13525.   *
  13526.   * To Fix:
  13527. @@ -1548,8 +1552,13 @@
  13528.                 IPPROTO_TCP, sk->opt,
  13529.                 sizeof(struct tcphdr),sk->ip_tos,sk->ip_ttl);
  13530.    if (tmp < 0) {
  13531. +      /* Finish anyway, treat this as a send that got lost. */
  13532.        buff->free=1;
  13533.      prot->wfree(sk,buff->mem_addr, buff->mem_len);
  13534. +    if(sk->state==TCP_ESTABLISHED)
  13535. +        sk->state=TCP_FIN_WAIT1;
  13536. +    else
  13537. +        sk->state=TCP_FIN_WAIT2;
  13538.      release_sock(sk);
  13539.      DPRINTF((DBG_TCP, "Unable to build header for fin.\n"));
  13540.      return;
  13541. @@ -2085,6 +2094,13 @@
  13542.                           sizeof(struct tcphdr),sk->ip_tos,sk->ip_ttl);
  13543.          if (tmp < 0) {
  13544.              kfree_skb(buff,FREE_WRITE);
  13545. +            if(sk->state==TCP_ESTABLISHED)
  13546. +                sk->state=TCP_FIN_WAIT1;
  13547. +            else
  13548. +                sk->state=TCP_FIN_WAIT2;
  13549. +            reset_timer(sk, TIME_CLOSE,4*sk->rto);
  13550. +            if(timeout)
  13551. +                tcp_time_wait(sk);
  13552.              DPRINTF((DBG_TCP, "Unable to build header for fin.\n"));
  13553.              release_sock(sk);
  13554.              return;
  13555. @@ -2915,6 +2931,7 @@
  13556.      case TCP_SYN_SENT:
  13557.      case TCP_ESTABLISHED:
  13558.          /* Contains the one that needs to be acked */
  13559. +        reset_timer(sk, TIME_CLOSE, TCP_TIMEOUT_LEN);
  13560.          sk->fin_seq = th->seq+1;
  13561.          sk->state = TCP_CLOSE_WAIT;
  13562.          if (th->rst) sk->shutdown = SHUTDOWN_MASK;
  13563. @@ -3447,6 +3464,15 @@
  13564.          kfree_skb(skb, FREE_READ);
  13565.          release_sock(sk);
  13566.          return(0);
  13567. +
  13568. +    case TCP_SYN_RECV:
  13569. +        if (th->syn) {
  13570. +            /* Probably a retransmitted syn */
  13571. +            kfree_skb(skb, FREE_READ);
  13572. +            release_sock(sk);
  13573. +            return(0);
  13574. +        }
  13575. +
  13576.  
  13577.      default:
  13578.          if (!tcp_sequence(sk, th, len, opt, saddr,dev)) {
  13579. diff -ubr -x RCS -x *.[ao] -x .depend -x .version -x .config -x System.map -x vmlinux -x bootstrap -x *~ -x config.old -x *.orig -x *.rej -x *# -x version.h -x autoconf.h --new-file linux-0.9pl3/tools/amiga/bootstrap.c linux-0.9pl4/tools/amiga/bootstrap.c
  13580. --- linux-0.9pl3/tools/amiga/bootstrap.c    Thu Sep 29 18:19:15 1994
  13581. +++ linux-0.9pl4/tools/amiga/bootstrap.c    Mon Nov 21 18:09:09 1994
  13582. @@ -2,12 +2,12 @@
  13583.  ** bootstrap.c -- This program loads the Linux/68k kernel into an Amiga
  13584.  **                and and launches it.
  13585.  **
  13586. -** Copyright 1993 by Hamish Macdonald, Greg Harp
  13587. +** Copyright 1993,1994 by Hamish Macdonald, Greg Harp
  13588.  **
  13589.  ** Modified 11-May-94 by Geert Uytterhoeven (uytterho@cs.kuleuven.ac.be)
  13590.  **     - A3640 MapROM check
  13591.  ** Modified 31-May-94 by Geert Uytterhoeven
  13592. -**     - Memory thrash problem solved
  13593. +**     - Memory trash problem solved
  13594.  **
  13595.  ** This file is subject to the terms and conditions of the GNU General Public
  13596.  ** License.  See the file README.legal in the main directory of this archive
  13597. @@ -48,6 +48,7 @@
  13598.  struct GfxBase *GfxBase;
  13599.  
  13600.  struct bootinfo bi;
  13601. +u_long bi_size = sizeof bi;
  13602.  
  13603.  caddr_t CustomBase = (caddr_t)CUSTOM_PHYSADDR;
  13604.  
  13605. @@ -78,6 +79,7 @@
  13606.      movel    _start_mem,a5
  13607.      movel    _mem_size,d0
  13608.      movel    _rd_size,d1
  13609. +    movel    _bi_size,d5
  13610.      movel    a3@(4),d2    | kexec.a_text
  13611.      movel    a3@(8),d3    | kexec.a_data
  13612.      movel    a3@(12),d4    | kexec.a_bss
  13613. @@ -104,12 +106,23 @@
  13614.      bras    1b
  13615.  2:
  13616.  
  13617. +                | /* copy bootinfo to end of bss */
  13618. +    movel    a4,a1        | src = (u long *)memptr + kexec.a_text + kexec.a_data);
  13619. +    addl    d2,a1
  13620. +    addl    d3,a1        | dest = end of bss (already in a0)
  13621. +    movel   d5,d7        | count = sizeof bi
  13622. +    subql    #1,d7
  13623. +1:    moveb    a1@+,a0@+    | while (--count > -1)
  13624. +    dbra    d7,1b        |    *dest++ = *src++
  13625. +    
  13626. +
  13627.                  | /* copy the ramdisk to the top of memory (from back to front) */
  13628.      movel    a5,a1        | dest = (u_long *)(start_mem + mem_size);
  13629.      addl    d0,a1
  13630. -    movel    a4,a2        | limit = (u_long *)(memptr + kexec.a_text + kexec.a_data);
  13631. +    movel    a4,a2        | limit = (u_long *)(memptr + kexec.a_text + kexec.a_data + sizeof bi);
  13632.      addl    d2,a2
  13633.      addl    d3,a2
  13634. +        addl    d5,a2
  13635.      movel    a2,a0        | src = (u_long *)((u_long)limit + rd_size);
  13636.      addl    d1,a0
  13637.  1:    cmpl    a0,a2
  13638. @@ -155,6 +168,7 @@
  13639.      movel    d7,d0
  13640.      notl    d0
  13641.      movel    d0,a0@
  13642. +    nop
  13643.      cmpl    a1@,d0
  13644.      jnes    1f
  13645.  /* MapROMmed A3640 present */
  13646. @@ -189,13 +203,12 @@
  13647.      char *ramdisk_name = NULL;
  13648.      char *memfile = NULL;
  13649.      u_long memreq;
  13650. -    struct nlist *nl;
  13651.      void (*startfunc)(void);
  13652.      long startcodesize;
  13653. -    u_long *stack, kbi_offset;
  13654. +    u_long *stack, text_offset;
  13655.  
  13656.      /* print the greet message */
  13657. -    puts(" Linux/68k Amiga Bootstrap version 1.9");
  13658. +    puts(" Linux/68k Amiga Bootstrap version 1.10");
  13659.      puts("Copyright 1993,1994 by Hamish Macdonald and Greg Harp\n");
  13660.  
  13661.      /* machine is Amiga */
  13662. @@ -526,6 +539,27 @@
  13663.          exit (EXIT_FAILURE);
  13664.      }
  13665.  
  13666. +    switch (N_MAGIC(kexec)) {
  13667. +      case ZMAGIC:
  13668. +        text_offset = N_TXTOFF(kexec);
  13669. +        break;
  13670. +      case QMAGIC:
  13671. +        text_offset = sizeof(kexec);
  13672. +        /* the text size includes the exec header; remove this */
  13673. +        kexec.a_text -= sizeof(kexec);
  13674. +        break;
  13675. +      default:
  13676. +        fprintf (stderr, "Wrong magic number %lo in kernel header\n",
  13677. +             N_MAGIC(kexec));
  13678. +        exit (EXIT_FAILURE);
  13679. +    }
  13680. +
  13681. +    /* Load the kernel at one page after start of mem */
  13682. +    start_mem += PAGE_SIZE;
  13683. +    mem_size -= PAGE_SIZE;
  13684. +    /* Align bss size to multiple of four */
  13685. +    kexec.a_bss = (kexec.a_bss + 3) & ~3;
  13686. +
  13687.      if (ramdisk_name) {
  13688.          if ((rfd = open (ramdisk_name, O_RDONLY)) == -1) {
  13689.              fprintf (stderr, "Unable to open ramdisk file %s\n",
  13690. @@ -540,22 +574,13 @@
  13691.      rd_size = bi.ramdisk_size << 10;
  13692.      bi.ramdisk_addr = (u_long)start_mem + mem_size - rd_size;
  13693.  
  13694. -    /* find offset to boot_info structure */
  13695. -    if (!(nl = get_nlist (kernel_name, "_boot_info"))) {
  13696. -        perror ("get_nlist");
  13697. -        exit (EXIT_FAILURE);
  13698. -    } else {
  13699. -        kbi_offset = nl->n_value - kexec.a_entry;
  13700. -        free (nl);
  13701. -    }
  13702. -
  13703. -    memreq = kexec.a_text + kexec.a_data + rd_size;
  13704. +    memreq = kexec.a_text + kexec.a_data + sizeof(bi) + rd_size;
  13705.      if (!(memptr = (char *)AllocMem (memreq, MEMF_FAST | MEMF_CLEAR))) {
  13706.          fprintf (stderr, "Unable to allocate memory\n");
  13707.          exit (EXIT_FAILURE);
  13708.      }
  13709.  
  13710. -    if (lseek (kfd, N_TXTOFF(kexec), L_SET) == -1) {
  13711. +    if (lseek (kfd, text_offset, L_SET) == -1) {
  13712.          fprintf (stderr, "Failed to seek to text\n");
  13713.          FreeMem ((void *)memptr, memreq);
  13714.          exit (EXIT_FAILURE);
  13715. @@ -565,11 +590,8 @@
  13716.          FreeMem ((void *)memptr, memreq);
  13717.          exit (EXIT_FAILURE);
  13718.      }
  13719. -    if (lseek (kfd, N_DATOFF(kexec), L_SET) == -1) {
  13720. -        fprintf (stderr, "Failed to seek to data\n");
  13721. -        FreeMem ((void *)memptr, memreq);
  13722. -        exit (EXIT_FAILURE);
  13723. -    }
  13724. +
  13725. +    /* data follows immediately after text */
  13726.      if (read (kfd, memptr + kexec.a_text, kexec.a_data) != kexec.a_data) {
  13727.          fprintf (stderr, "Failed to read data\n");
  13728.          FreeMem ((void *)memptr, memreq);
  13729. @@ -577,8 +599,9 @@
  13730.      }
  13731.      close (kfd);
  13732.  
  13733. -    /* copy the boot_info struct to the kernel image */
  13734. -    memcpy ((void *)(memptr + kbi_offset), &bi, sizeof(bi));
  13735. +    /* copy the boot_info struct to the end of the kernel image */
  13736. +    memcpy ((void *)(memptr + kexec.a_text + kexec.a_data), &bi,
  13737. +        sizeof(bi));
  13738.  
  13739.      if (rfd != -1) {
  13740.          if (lseek (rfd, 0, L_SET) == -1) {
  13741. @@ -586,8 +609,8 @@
  13742.              FreeMem ((void *)memptr, memreq);
  13743.              exit (EXIT_FAILURE);
  13744.          }
  13745. -        if (read (rfd, memptr + kexec.a_text + kexec.a_data,
  13746. -              rd_size) != rd_size) {
  13747. +        if (read (rfd, memptr + kexec.a_text + kexec.a_data 
  13748. +              + sizeof(bi), rd_size) != rd_size) {
  13749.              fprintf (stderr, "Failed to read ramdisk file\n");
  13750.              FreeMem ((void *)memptr, memreq);
  13751.              exit (EXIT_FAILURE);
  13752. @@ -622,12 +645,15 @@
  13753.                  (u_long)memptr + kexec.a_text + kexec.a_data,
  13754.                  bi.ramdisk_size);
  13755.  
  13756. -        printf ("\nKernel text at %#lx, code size %d\n",
  13757. -            start_mem + N_TXTADDR(kexec), kexec.a_text);
  13758. -        printf ("Kernel data at %#lx, data size %d\n",
  13759. -            start_mem + N_DATADDR(kexec), kexec.a_data );
  13760. -        printf ("Kernel bss  at %#lx, bss  size %d\n",
  13761. -            start_mem + N_BSSADDR(kexec), kexec.a_bss );
  13762. +        printf ("\nKernel text at %#lx, code size %x\n",
  13763. +            start_mem, kexec.a_text);
  13764. +        printf ("Kernel data at %#lx, data size %x\n",
  13765. +            start_mem + kexec.a_text, kexec.a_data );
  13766. +        printf ("Kernel bss  at %#lx, bss  size %x\n",
  13767. +            start_mem + kexec.a_text + kexec.a_data,
  13768. +            kexec.a_bss );
  13769. +        printf ("boot info at %#lx\n", start_mem + kexec.a_text
  13770. +            + kexec.a_data + kexec.a_bss);
  13771.  
  13772.          printf ("\nKernel entry is %#x\n", kexec.a_entry );
  13773.  
  13774. diff -ubr -x RCS -x *.[ao] -x .depend -x .version -x .config -x System.map -x vmlinux -x bootstrap -x *~ -x config.old -x *.orig -x *.rej -x *# -x version.h -x autoconf.h --new-file linux-0.9pl3/tools/amiga/bootstrap.h linux-0.9pl4/tools/amiga/bootstrap.h
  13775. --- linux-0.9pl3/tools/amiga/bootstrap.h    Sun Aug 14 10:29:11 1994
  13776. +++ linux-0.9pl4/tools/amiga/bootstrap.h    Sat Nov 12 12:40:13 1994
  13777. @@ -128,12 +128,6 @@
  13778.   */
  13779.  #define GFXG_AGA    (GFXF_AA_ALICE|GFXF_AA_LISA)
  13780.  
  13781. -/*
  13782. - * Get an nlist structure containing the information
  13783. - * for the given symbol from the given file.
  13784. - */
  13785. -extern struct nlist *get_nlist (const char *fname, const char *symname);
  13786. -
  13787.  struct Library;
  13788.  
  13789.  extern struct ExecBase *SysBase;
  13790. diff -ubr -x RCS -x *.[ao] -x .depend -x .version -x .config -x System.map -x vmlinux -x bootstrap -x *~ -x config.old -x *.orig -x *.rej -x *# -x version.h -x autoconf.h --new-file linux-0.9pl3/tools/amiga/get_nlist.c linux-0.9pl4/tools/amiga/get_nlist.c
  13791. --- linux-0.9pl3/tools/amiga/get_nlist.c    Sun Aug 14 10:29:11 1994
  13792. +++ linux-0.9pl4/tools/amiga/get_nlist.c    Wed Dec 31 19:00:00 1969
  13793. @@ -1,97 +0,0 @@
  13794. -/*
  13795. -** get_nlist.c -- This file contains the routines for getting a symbol
  13796. -**          table entry when booting the Amiga Linux kernel.
  13797. -**
  13798. -** Copyright 1993 by Hamish Macdonald
  13799. -**
  13800. -** This file is subject to the terms and conditions of the GNU General Public
  13801. -** License.  See the file README.legal in the main directory of this archive
  13802. -** for more details.
  13803. -**
  13804. -*/
  13805. -
  13806. -
  13807. -#include <stdlib.h>
  13808. -#include <stdio.h>
  13809. -#include <sys/fcntl.h>
  13810. -#include <unistd.h>
  13811. -#include <linux/a.out.h>
  13812. -
  13813. -struct nlist *get_nlist (const char *fname, const char *symname)
  13814. -{
  13815. -    int fd = open (fname, O_RDONLY);
  13816. -    struct exec ex;
  13817. -    struct nlist *nl, *p = NULL, *syms;
  13818. -    char *strs;
  13819. -    off_t filesize;
  13820. -    long strsize, numsyms;
  13821. -
  13822. -    if (fd == -1)
  13823. -    return NULL;
  13824. -
  13825. -#ifdef DEBUG
  13826. -    printf ("fd is %d\n", fd);
  13827. -#endif
  13828. -
  13829. -    read (fd, &ex, sizeof(ex));
  13830. -    if (!ex.a_syms) {
  13831. -    close (fd);
  13832. -    return NULL;
  13833. -    }
  13834. -
  13835. -#ifdef DEBUG
  13836. -    printf ("%d bytes of symbol data\n", ex.a_syms);
  13837. -#endif
  13838. -
  13839. -    syms = (struct nlist *)malloc (ex.a_syms);
  13840. -    if (!syms) {
  13841. -    close (fd);
  13842. -    return NULL;
  13843. -    }
  13844. -    lseek (fd, N_SYMOFF(ex), L_SET);
  13845. -    read (fd, syms, ex.a_syms);
  13846. -    numsyms = ex.a_syms / sizeof (struct nlist);
  13847. -#ifdef DEBUG
  13848. -    printf ("there are %d symbols\n", numsyms);
  13849. -#endif
  13850. -
  13851. -    filesize = lseek (fd, 0L, L_XTND);
  13852. -#ifdef DEBUG
  13853. -    printf ("there are %d characters in the file\n", filesize);
  13854. -#endif
  13855. -    strsize = filesize - N_STROFF(ex);
  13856. -#ifdef DEBUG
  13857. -    printf ("%d characters in the string table\n", strsize);
  13858. -#endif
  13859. -
  13860. -    strs = (char *)malloc (strsize);
  13861. -    if (!strs) {
  13862. -    free (syms);
  13863. -    close (fd);
  13864. -    return NULL;
  13865. -    }
  13866. -    lseek (fd, N_STROFF(ex), L_SET);
  13867. -    read (fd, strs, strsize);
  13868. -
  13869. -    for (nl = syms; nl < syms + numsyms; nl++) {
  13870. -#ifdef DEBUG
  13871. -    printf ("checking symbol number %d, name %s\n",
  13872. -        nl - syms, strs + nl->n_un.n_strx);
  13873. -#endif
  13874. -    if (strcmp (symname, strs + nl->n_un.n_strx) == 0
  13875. -        && nl->n_type == N_BSS | N_EXT) {
  13876. -        p = (struct nlist *)malloc (sizeof (struct nlist)
  13877. -                    + strlen(strs + nl->n_un.n_strx) + 1);
  13878. -        if (!p)
  13879. -        break;
  13880. -        *p = *nl;
  13881. -        p->n_un.n_name = (char *)(p+1);
  13882. -        strcpy (p->n_un.n_name, strs + nl->n_un.n_strx);
  13883. -    }
  13884. -    }
  13885. -
  13886. -    free (strs);
  13887. -    free (syms);
  13888. -    close (fd);
  13889. -    return p;
  13890. -}
  13891. diff -ubr -x RCS -x *.[ao] -x .depend -x .version -x .config -x System.map -x vmlinux -x bootstrap -x *~ -x config.old -x *.orig -x *.rej -x *# -x version.h -x autoconf.h --new-file linux-0.9pl3/tools/atari/Makefile linux-0.9pl4/tools/atari/Makefile
  13892. --- linux-0.9pl3/tools/atari/Makefile    Sun Aug 14 10:29:12 1994
  13893. +++ linux-0.9pl4/tools/atari/Makefile    Thu Nov 24 21:11:00 1994
  13894. @@ -3,19 +3,10 @@
  13895.  CFLAGS    := -Wall -O2 -fno-defer-pop -mint -s
  13896.  LD        := d:/gnu/bin/gcc.ttp
  13897.  LDFLAGS    := -mint -D__GNUC__
  13898. -AS        := d:/gnu/bin/gcc.ttp -c
  13899.  
  13900. -bootstra.ttp: boot_asm.o bootstra.o
  13901. +bootstra.ttp: bootstra.o
  13902.      $(LD) $(LDFLAGS) -o $@ $^
  13903.      prgflags 7 7 $@
  13904.      cp $@ d:/linux
  13905.  
  13906.  bootstra.o: bootstra.c bootinfo.h
  13907. -
  13908. -gen_nlis.o: gen_nlis.c
  13909. -
  13910. -boot_asm.o: boot_asm.S
  13911. -
  13912. -%.s: %.c
  13913. -    $(CC) $(CFLAGS) -S $^ -o $@
  13914. -
  13915. diff -ubr -x RCS -x *.[ao] -x .depend -x .version -x .config -x System.map -x vmlinux -x bootstrap -x *~ -x config.old -x *.orig -x *.rej -x *# -x version.h -x autoconf.h --new-file linux-0.9pl3/tools/atari/bootstrap.c linux-0.9pl4/tools/atari/bootstrap.c
  13916. --- linux-0.9pl3/tools/atari/bootstrap.c    Sun Aug 14 10:29:12 1994
  13917. +++ linux-0.9pl4/tools/atari/bootstrap.c    Mon Nov 21 18:12:14 1994
  13918. @@ -8,6 +8,15 @@
  13919.  ** for more details.
  13920.  **
  13921.  ** History:
  13922. +**      14 Nov 1994 YANML (Yet Another New Memory Layout :-) kernel
  13923. +**            start address is KSTART_ADDR + PAGE_SIZE, this
  13924. +**            does not need the ugly klugde with
  13925. +**            -fwritable-strings (++andreas)
  13926. +**      09 Sep 1994 Adapted to the new memory layout: All the boot_info entry
  13927. +**                  mentions all ST-Ram and the mover is located somewhere
  13928. +**                  in the middle of memory (roman)
  13929. +**                  Added the default arguments file known from the other
  13930. +**                  bootstrap version
  13931.  **      19 Feb 1994 Changed everything so that it works? (rdv)
  13932.  **      14 Mar 1994 New mini-copy routine used (rdv)
  13933.  */
  13934. @@ -17,6 +26,7 @@
  13935.  #include <unistd.h>
  13936.  #include <stddef.h>
  13937.  #include <string.h>
  13938. +#include <ctype.h>
  13939.  #include "sysvars.h"
  13940.  #include <osbind.h>
  13941.  #include <sys/types.h>
  13942. @@ -34,7 +44,9 @@
  13943.  
  13944.  extern char *optarg;
  13945.  extern int optind;
  13946. -extern struct nlist *get_nlist(const char *fname, const char *symname);
  13947. +static void get_default_args( int *argc, char ***argv );
  13948. +/* This is missing in <unistd.h> */
  13949. +extern int sync (void);
  13950.  
  13951.  struct bootinfo bi;
  13952.  u_long *cookiejar;
  13953. @@ -92,50 +104,79 @@
  13954.      subql    #4,d0
  13955.      jcc    1b
  13956.  
  13957. +    tstl    d1
  13958. +    beq        3f
  13959. +
  13960.  2:    movel    a3@-,a2@-       /* copy the ramdisk starting at the end */
  13961.      subql    #4,d1
  13962.      jcc    2b
  13963.  
  13964. -    jmp    a4@             /* jump to the start of the kernel */
  13965. +3:    jmp    a4@             /* jump to the start of the kernel */
  13966.  _copyallend:
  13967.  ");
  13968.  
  13969.  extern char copyall, copyallend;
  13970.  
  13971. -static void volatile boot_exit(int status)
  13972. +/* ++andreas: this must be inline due to Super */
  13973. +static inline void boot_exit (int) __attribute__ ((noreturn));
  13974. +static inline void boot_exit(int status)
  13975.  {
  13976.      /* first go back to user mode */
  13977.      (void)Super(userstk);
  13978. +    getchar();
  13979.      exit(status);
  13980.  }
  13981.  
  13982.  int main(int argc, char *argv[])
  13983.  {
  13984. -    int debugflag = 0, ch, kfd, rfd = -1, lang, i;
  13985. +    int debugflag = 0, ch, kfd, rfd = -1, i, ignore_ttram = 0;
  13986. +    int load_to_stram = 0;
  13987. +#if 0
  13988. +    int lang;
  13989. +#endif
  13990.      char *ramdisk_name, *kernel_name, *memptr;
  13991.      u_long ST_ramsize, TT_ramsize, memreq;
  13992. -    u_long cpu_type, fpu_type, mch_type, mint, language;
  13993. -    struct nlist *nl;
  13994. +    u_long cpu_type, fpu_type, mch_type, mint;
  13995. +#if 0
  13996. +    u_long language;
  13997. +#endif
  13998.      struct exec kexec;
  13999. +#if 0
  14000.      OSHEADER *os_header;
  14001. -    u_long start_mem, mem_size, rd_size, kbi_offset;
  14002. +#endif
  14003. +    u_long start_mem, mem_size, rd_size, text_offset;
  14004. +#if 0
  14005. +    u_long mover_size;
  14006. +    void   *mover_addr;
  14007. +#endif
  14008.  
  14009.      ramdisk_name = NULL;
  14010.      kernel_name = "vmlinux";
  14011.  
  14012.      /* print the startup message */
  14013. -    puts("\fLinux/68k Atari Bootstrap version 0.2");
  14014. -    puts("Copyright 1993,1994 by Arjan Knor, Robert de Vries\n");
  14015. +    puts("\fLinux/68k Atari Bootstrap version 0.4");
  14016. +    puts("Copyright 1993,1994 by Arjan Knor, Robert de Vries, Roman Hodek, Andreas Schwab\n");
  14017. +
  14018. +    /* ++roman: If no arguments on the command line, read them from
  14019. +     * file */
  14020. +    if (argc == 1)
  14021. +        get_default_args( &argc, &argv );
  14022.  
  14023.      /* machine is Atari */
  14024.      bi.machtype = MACH_ATARI;
  14025.  
  14026.      /* check arguments */
  14027. -    while ((ch = getopt(argc, argv, "dk:r:")) != EOF)
  14028. +    while ((ch = getopt(argc, argv, "dtsk:r:")) != EOF)
  14029.      switch (ch) {
  14030.        case 'd':
  14031.          debugflag = 1;
  14032.          break;
  14033. +      case 't':
  14034. +        ignore_ttram = 1;
  14035. +        break;
  14036. +      case 's':
  14037. +        load_to_stram = 1;
  14038. +        break;
  14039.        case 'k':
  14040.          kernel_name = optarg;
  14041.          break;
  14042. @@ -264,7 +305,8 @@
  14043.      /* The size must be a multiple of 1MB. */
  14044.      i = 0;
  14045.      TT_ramsize = 0;
  14046. -    if (mch_type == MACH_TT && *ramtop) {
  14047. +    if (!ignore_ttram &&
  14048. +        (mch_type == MACH_TT || mch_type == MACH_FALCON) && *ramtop) {
  14049.      /* the 'ramtop' variable at 0x05a4 is not
  14050.       * officially documented. We use it anyway
  14051.       * because it is the only way to get the TTram size.
  14052. @@ -277,28 +319,31 @@
  14053.  
  14054.      printf("TT-RAM: %ld Mb; ", TT_ramsize);
  14055.      }
  14056. -
  14057. -    bi.memory[i].addr = PAGE_SIZE; /* do not use the exception space
  14058. -                   (this comes down to the first page) */
  14059. -    bi.memory[i].size = (*phystop - bi.memory[i].addr) & ~(MB - 1);
  14060. +    bi.memory[i].addr = 0;
  14061. +    bi.memory[i].size = *phystop & ~(MB - 1);
  14062.      ST_ramsize = bi.memory[i].size / MB;
  14063.  
  14064. -    bi.bi_atari.stram_start = bi.memory[i].addr + bi.memory[i].size;
  14065. -    bi.bi_atari.stram_size = *phystop - bi.bi_atari.stram_start;
  14066. -
  14067.      i++;
  14068.  
  14069. -    printf("ST-RAM: %ld Mb; %ld Kb unmapped; ", ST_ramsize,
  14070. -       bi.bi_atari.stram_size / 1024);
  14071. +    printf("ST-RAM: %ld Mb; ", ST_ramsize );
  14072.  
  14073.      bi.num_memory = i;
  14074.  
  14075. +    if (load_to_stram && i > 1)
  14076. +      {
  14077. +    /* Put ST-RAM first in the list of mem blocks */
  14078. +    struct mem_info temp = bi.memory[i - 1];
  14079. +    bi.memory[i - 1] = bi.memory[0];
  14080. +    bi.memory[0] = temp;
  14081. +      }
  14082. +
  14083.      /* verify that there is enough RAM; ST- and TT-RAM combined */
  14084.      if (ST_ramsize + TT_ramsize < MIN_RAMSIZE) {
  14085.      puts("Not enough RAM. Aborting...");
  14086.      boot_exit(10);
  14087.      }
  14088.  
  14089. +#if 0    
  14090.      /* Get language/keyboard info */
  14091.      /* TODO: do we need this ? */
  14092.      /* Could be used to auto-select keyboard map later on. (rdv) */
  14093. @@ -354,6 +399,7 @@
  14094.      }
  14095.      printf("\n");
  14096.      }
  14097. +#endif
  14098.  
  14099.      /*
  14100.       * Copy command line options into the kernel command line.
  14101. @@ -394,6 +440,27 @@
  14102.      boot_exit (EXIT_FAILURE);
  14103.      }
  14104.  
  14105. +    switch (N_MAGIC(kexec)) {
  14106. +    case ZMAGIC:
  14107. +    text_offset = N_TXTOFF(kexec);
  14108. +    break;
  14109. +    case QMAGIC:
  14110. +    text_offset = sizeof(kexec);
  14111. +    /* the text size includes the exec header; remove this */
  14112. +    kexec.a_text -= sizeof(kexec);
  14113. +    break;
  14114. +    default:
  14115. +    fprintf (stderr, "Wrong magic number %lo in kernel header\n",
  14116. +         N_MAGIC(kexec));
  14117. +    boot_exit (EXIT_FAILURE);
  14118. +    }
  14119. +
  14120. +    /* Load the kernel one page after start of mem */
  14121. +    start_mem += PAGE_SIZE;
  14122. +    mem_size -= PAGE_SIZE;
  14123. +    /* Align bss size to multiple of four */
  14124. +    kexec.a_bss = (kexec.a_bss + 3) & ~3;
  14125. +
  14126.      /* init ramdisk */
  14127.      if(ramdisk_name) {
  14128.      if((rfd = open(ramdisk_name, O_RDONLY)) == -1) {
  14129. @@ -409,23 +476,55 @@
  14130.      rd_size = bi.ramdisk_size << 10;
  14131.      bi.ramdisk_addr = (u_long)start_mem + mem_size - rd_size;
  14132.  
  14133. -    /* find offset to boot_info structure */
  14134. -    if (!(nl = get_nlist (kernel_name, "_boot_info")))
  14135. -    {
  14136. -    perror ("get_nlist");
  14137. -    boot_exit (EXIT_FAILURE);
  14138. -    }
  14139. +    /* calculate the total required amount of memory */
  14140. +    memreq = kexec.a_text + kexec.a_data + kexec.a_bss + sizeof (bi) + rd_size;
  14141.  
  14142. -    kbi_offset = nl->n_value - kexec.a_entry;
  14143. -    free (nl);
  14144. +    /* ++andreas: This not needed any more, left in for reference :-) */
  14145. +#if 0
  14146.  
  14147. -    /* calculate the total required amount of memory */
  14148. -    memreq = kexec.a_text + kexec.a_data + kexec.a_bss + rd_size;
  14149. +    /* Allocate memory for the mover routine. It has to be disjunct
  14150. +     * from all three other areas, the kernel destination, the ramdisk
  14151. +     * destination and the load buffer for both. Because the mover
  14152. +     * space is allocated separately from the load buffer, it cannot
  14153. +     * overlap that one.
  14154. +     * To get some appropriate memory for the mover, the following
  14155. +     * steps are tried:
  14156. +     *  - Leave it where it is (in bootstrap's code space)
  14157. +     *  - If the kernel will go into TT-Ram, allocate memory from the ST-Ram
  14158. +     *  - Allocate some memory before allocating the load buffer.
  14159. +     *  - Allocate some memory after the load buffer
  14160. +     *  - If all that failed, it is unlikely to find a suitable place.
  14161. +     *    But to be sure, memory is alloced in bigger steps (32K)
  14162. +     *    until there is no memory left.
  14163. +     */
  14164. +#define    IS_DISJUNCT(a1,s1,a2,s2) ( (a2) > (a1)+(s1) || (a2)+(s2) < (a1) )
  14165. +#define MOVER_DISJUNCT(addr)                                        \
  14166. +    (IS_DISJUNCT( start_mem, kexec.a_text+kexec.a_data+kexec.a_bss,    \
  14167. +                  (unsigned long)(addr), mover_size ) &&            \
  14168. +     IS_DISJUNCT( start_mem + mem_size - rd_size, rd_size,            \
  14169. +                  (unsigned long)(addr), mover_size ))
  14170. +    
  14171. +    mover_size = ©allend - ©all;
  14172. +    mover_addr = ©all;
  14173. +
  14174. +    if (!MOVER_DISJUNCT(mover_addr) && TT_ramsize) {
  14175. +        /* If there is TT-Ram, try to put the mover into ST-Ram */
  14176. +        unsigned long addr;
  14177. +        addr = Mxalloc( mover_size, 0 );
  14178. +        if ((signed long)addr > 0) mover_addr = addr;
  14179. +    }
  14180. +    if (!MOVER_DISJUNCT(mover_addr)) {
  14181. +         if (!(mover_addr = (void *)Malloc( mover_size ))) {
  14182. +            fprintf( stderr, "Unable to allocate memory for mover code\n" );
  14183. +            boot_exit( EXIT_FAILURE );
  14184. +        }
  14185. +    }
  14186. +#endif
  14187.   
  14188.      /* allocate RAM for the kernel */
  14189.      if (!(memptr = (char *)Malloc (memreq)))
  14190.      {
  14191. -    fprintf (stderr, "Unable to allocate memory\n");
  14192. +    fprintf (stderr, "Unable to allocate memory for kernel and ramdisk\n");
  14193.      boot_exit (EXIT_FAILURE);
  14194.      }
  14195.      else
  14196. @@ -433,8 +532,18 @@
  14197.  
  14198.      (void)memset(memptr, 0, memreq);
  14199.  
  14200. +#if 0
  14201. +    while( !MOVER_DISJUNCT(mover_addr) ) {
  14202. +         if (!(mover_addr = (void *)Malloc( mover_size ))) {
  14203. +            fprintf( stderr, "Unable to allocate memory for mover code\n" );
  14204. +            boot_exit( EXIT_FAILURE );
  14205. +        }
  14206. +        (void)Malloc( 32*1024 );
  14207. +    }
  14208. +#endif
  14209. +    
  14210.      /* read the text and data segments from the kernel image */
  14211. -    if (lseek (kfd, N_TXTOFF(kexec), SEEK_SET) == -1)
  14212. +    if (lseek (kfd, text_offset, SEEK_SET) == -1)
  14213.      {
  14214.      fprintf (stderr, "Failed to seek to text\n");
  14215.      Mfree ((void *)memptr);
  14216. @@ -446,12 +555,8 @@
  14217.      Mfree ((void *)memptr);
  14218.      boot_exit (EXIT_FAILURE);
  14219.      }
  14220. -    if (lseek (kfd, N_DATOFF(kexec), SEEK_SET) == -1)
  14221. -    {
  14222. -    fprintf (stderr, "Failed to seek to data\n");
  14223. -    Mfree ((void *)memptr);
  14224. -    boot_exit (EXIT_FAILURE);
  14225. -    }
  14226. +
  14227. +    /* data follows immediately after text */
  14228.      if (read (kfd, memptr + kexec.a_text, kexec.a_data) != kexec.a_data)
  14229.      {
  14230.      fprintf (stderr, "Failed to read data\n");
  14231. @@ -460,8 +565,9 @@
  14232.      }
  14233.      close (kfd);
  14234.  
  14235. -    /* copy the boot_info struct to the kernel image */
  14236. -    memcpy ((void *)(memptr + kbi_offset), &bi, sizeof(bi));
  14237. +    /* copy the boot_info struct to the end of the kernel image */
  14238. +    memcpy ((void *)(memptr + kexec.a_text + kexec.a_data + kexec.a_bss),
  14239. +        &bi, sizeof(bi));
  14240.  
  14241.      /* read the ramdisk image */
  14242.      if (rfd != -1)
  14243. @@ -472,7 +578,7 @@
  14244.          Mfree ((void *)memptr);
  14245.          boot_exit (EXIT_FAILURE);
  14246.      }
  14247. -    if (read (rfd, memptr + kexec.a_text + kexec.a_data + kexec.a_bss,
  14248. +    if (read (rfd, memptr + kexec.a_text + kexec.a_data + kexec.a_bss + sizeof (bi),
  14249.            rd_size) != rd_size)
  14250.      {
  14251.          fprintf (stderr, "Failed to read ramdisk file\n");
  14252. @@ -491,13 +597,13 @@
  14253.              bi.ramdisk_size);
  14254.  
  14255.      printf ("\nKernel text at %#lx, code size %d\n",
  14256. -        start_mem + N_TXTADDR(kexec), kexec.a_text);
  14257. +        start_mem, kexec.a_text);
  14258.      printf ("Kernel data at %#lx, data size %d\n",
  14259. -        start_mem + N_DATADDR(kexec), kexec.a_data );
  14260. +        start_mem + kexec.a_text, kexec.a_data );
  14261.      printf ("Kernel bss  at %#lx, bss  size %d\n",
  14262. -        start_mem + N_BSSADDR(kexec), kexec.a_bss );
  14263. -    printf ("\nKernel boot_info is at %#lx physical, %#lx virtual\n",
  14264. -        start_mem + kbi_offset, kexec.a_entry + kbi_offset);
  14265. +        start_mem + kexec.a_text + kexec.a_data, kexec.a_bss );
  14266. +    printf ("\nboot_info is at %#lx\n",
  14267. +        start_mem + kexec.a_text + kexec.a_data + kexec.a_bss);
  14268.      printf ("\nKernel entry is %#x\n", kexec.a_entry );
  14269.      printf ("ramdisk dest top is %#lx\n", start_mem + mem_size);
  14270.      printf ("ramdisk lower limit is %#lx\n",
  14271. @@ -505,6 +611,11 @@
  14272.      printf ("ramdisk src top is %#lx\n",
  14273.          (u_long)(memptr + kexec.a_text + kexec.a_data + kexec.a_bss) +
  14274.          rd_size);
  14275. +#if 0
  14276. +    printf ("mover code resides from %#lx to %#lx\n",
  14277. +            (unsigned long)mover_addr,
  14278. +            (unsigned long)mover_addr + mover_size - 1 );
  14279. +#endif
  14280.  
  14281.      printf ("Type a key to continue the Linux boot...");
  14282.      fflush (stdout);
  14283. @@ -524,11 +635,20 @@
  14284.      /* ..and any MMU translation */
  14285.      disable_mmu();
  14286.  
  14287. -    /* copy mover code to a safe place */
  14288. -    memcpy((void*)0x400, ©all, ©allend - ©all);
  14289. +    /* copy mover code to a safe place if needed */
  14290. +#if 0
  14291. +    if (mover_addr != ©all)
  14292. +        memcpy( mover_addr, ©all, mover_size );
  14293. +#else
  14294. +    memcpy ((void *) 0x400, ©all, ©allend - ©all);
  14295. +#endif
  14296.  
  14297.      /* setup stack */
  14298. -    change_stack((void*)PAGE_SIZE);
  14299. +#if 0
  14300. +    change_stack( start_mem ? PAGE_SIZE : (void*)start_mem+mem_size-rd_size-8);
  14301. +#else
  14302. +    change_stack ((void *) PAGE_SIZE);
  14303. +#endif
  14304.  
  14305.      /*
  14306.       * On the Atari you can have two situations:
  14307. @@ -547,12 +667,87 @@
  14308.       * This is more than enough for the miniscule mover routine (16 bytes).
  14309.       */
  14310.      
  14311. +#if 0
  14312. +    /* New copy scheme for new memory layout: The first 8 kernel bytes
  14313. +     * are nop's that needn't be copied. This avoids accessing the ROM
  14314. +     * bytes at the start of ST-Ram if the kernel will go there. The
  14315. +     * first arguement is the kernel start address, too.
  14316. +     * The mover code was copied to a place disjunct from any of the
  14317. +     * destination areas. 
  14318. +     */
  14319. +    
  14320. +    jump_to_mover((char *) start_mem + 8, memptr + 8,
  14321. +          (char *) start_mem + mem_size, memptr + memreq,
  14322. +          kexec.a_text + kexec.a_data + kexec.a_bss - 8,
  14323. +          rd_size,
  14324. +          mover_addr );
  14325. +#else
  14326.      jump_to_mover((char *) start_mem, memptr,
  14327.            (char *) start_mem + mem_size, memptr + memreq,
  14328. -          kexec.a_text + kexec.a_data + kexec.a_bss,
  14329. +          kexec.a_text + kexec.a_data + kexec.a_bss + sizeof (bi),
  14330.            rd_size,
  14331. -          (void*)0x400);
  14332. +          (void *) 0x400);
  14333. +#endif
  14334.      for (;;);
  14335.      /* NOTREACHED */
  14336.  }
  14337. +
  14338. +
  14339. +
  14340. +#define    MAXARGS        30
  14341. +
  14342. +static void get_default_args( int *argc, char ***argv )
  14343. +
  14344. +{    FILE        *f;
  14345. +    static char    *nargv[MAXARGS];
  14346. +    char        arg[256], *p;
  14347. +    int            c, quote, state;
  14348. +
  14349. +    if (!(f = fopen( "bootargs", "r" )))
  14350. +        return;
  14351. +    
  14352. +    *argc = 1;
  14353. +    if (***argv)
  14354. +      nargv[0] = **argv;
  14355. +    else
  14356. +      nargv[0] = "bootstrap";
  14357. +    *argv = nargv;
  14358. +
  14359. +    quote = state = 0;
  14360. +    p = arg;
  14361. +    while( (c = fgetc(f)) != EOF ) {        
  14362. +
  14363. +        if (state == 0) {
  14364. +            /* outside args, skip whitespace */
  14365. +            if (!isspace(c)) {
  14366. +                state = 1;
  14367. +                p = arg;
  14368. +            }
  14369. +        }
  14370. +        
  14371. +        if (state) {
  14372. +            /* inside an arg: copy it into 'arg', obeying quoting */
  14373. +            if (!quote && (c == '\'' || c == '"'))
  14374. +                quote = c;
  14375. +            else if (quote && c == quote)
  14376. +                quote = 0;
  14377. +            else if (!quote && isspace(c)) {
  14378. +                /* end of this arg */
  14379. +                *p = 0;
  14380. +                nargv[(*argc)++] = strdup(arg);
  14381. +                state = 0;
  14382. +            }
  14383. +            else
  14384. +                *p++ = c;
  14385. +        }
  14386. +    }
  14387. +    if (state) {
  14388. +        /* last arg finished by EOF! */
  14389. +        *p = 0;
  14390. +        nargv[(*argc)++] = strdup(arg);
  14391. +    }
  14392. +    fclose( f );
  14393. +    
  14394. +    nargv[*argc] = 0;
  14395. +}    
  14396.  
  14397.